View Javadoc
1   /* Generated By:JJTree&JavaCC: Do not edit this line. PLSQLParser.java */
2   /* Copyright (C) 2002 Albert Tumanov
3   
4   This library is free software; you can redistribute it and/or
5   modify it under the terms of the GNU Lesser General Public
6   License as published by the Free Software Foundation; either
7   version 2.1 of the License, or (at your option) any later version.
8   
9   This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13  
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  
18  */
19  
20  package net.sourceforge.pmd.lang.plsql.ast;
21  
22  import java.io.*;
23  import net.sourceforge.pmd.lang.ast.Node;
24  import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25  import net.sourceforge.pmd.lang.ast.TokenMgrError;
26  
27  public class PLSQLParser/*@bgen(jjtree)*/implements PLSQLParserTreeConstants, PLSQLParserConstants {/*@bgen(jjtree)*/
28    protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29    /**
30     * main method, for testing only.
31     * @param args
32     */
33    public static void main(String[] args)
34        throws ParseException {
35  
36      PLSQLParser parser = new PLSQLParser(System.in);
37      PLSQLNode node = parser.Input();
38  
39      String s;
40      s = "qwerty";
41  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
42      s = "\u005c"qwerty\u005c"";
43  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
44      s = "\u005c"qwerty\u005c".uiop";
45  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
46      s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
48    }
49  
50    /**
51     Return canonical version of the Oracle
52    */
53    public static String canonicalName(String name)
54    {
55      StringBuilder s =  null ;
56  
57  
58      if (null == name) {
59        return name;
60      }
61      else if (-1 == name.indexOf('"') )
62      {
63        name = name.toUpperCase();
64        s = new StringBuilder(name.trim());
65      }
66      else
67      {
68        StringBuilder oldString = new StringBuilder( name.trim().length());
69        s = new StringBuilder(name.trim());
70        boolean quotedCharacter = false ;
71        for (int i=0; i<oldString.length(); i++) {
72          if (oldString.charAt(i) == '"')
73          {
74  
75            oldString.deleteCharAt(i);
76            i--;
77  
78            //Toggle whether following characters are quoted or not
79            quotedCharacter = !quotedCharacter ;
80          }
81          else
82          {
83            s.append( quotedCharacter
84                      ? s.charAt(i)
85                      : Character.toUpperCase(s.charAt(i))
86                    );
87          }
88        }
89      }
90      return s.toString();
91    }
92  
93  /**
94   * 2006-05-22 - Matthias Hendler - Added parsing of triggers and global functions/procedures
95   *                                 Refactored printing of custom tags into the XML/DOM.
96   *                                 Custom tags are language independent. Reserved tags are linked
97   *                                 to the documented language like RETURN, PARAM and THROWS.
98   */
99  
100 /**
101  * 2006-05-22 - Matthias Hendler - added globalBody()
102  */
103   final public ASTInput Input() throws ParseException {
104                     /*@bgen(jjtree) Input */
105   ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106   boolean jjtc000 = true;
107   jjtree.openNodeScope(jjtn000);
108     try {
109       label_1:
110       while (true) {
111         switch (jj_nt.kind) {
112         case 2:
113         case 3:
114         case 21:
115         case ALTER:
116         case BEGIN:
117         case COLUMN:
118         case COMMENT:
119         case COMMIT:
120         case CONNECT:
121         case CREATE:
122         case DECLARE:
123         case DELETE:
124         case DROP:
125         case EXECUTE:
126         case EXIT:
127         case FUNCTION:
128         case GRANT:
129         case INSERT:
130         case LOCK:
131         case MERGE:
132         case PACKAGE:
133         case PROMPT:
134         case PROCEDURE:
135         case RENAME:
136         case REVOKE:
137         case ROLLBACK:
138         case SAVEPOINT:
139         case SELECT:
140         case SET:
141         case START:
142         case TRIGGER:
143         case TYPE:
144         case SHOW:
145         case SPOOL:
146         case UPDATE:
147         case WITH:
148         case ANALYZE:
149         case ASSOCIATE:
150         case AUDIT:
151         case DDL:
152         case DISASSOCIATE:
153         case NOAUDIT:
154         case TRUNCATE:
155         case ACCEPT:
156         case COPY:
157         case DEFINE:
158         case DISCONNECT:
159         case HOST:
160         case PRINT:
161         case QUIT:
162         case REMARK:
163         case UNDEFINE:
164         case VARIABLE:
165         case WHENEVER:
166         case IDENTIFIER:
167           ;
168           break;
169         default:
170           jj_la1[0] = jj_gen;
171           break label_1;
172         }
173         if (jj_2_1(7)) {
174           PackageSpecification();
175         } else if (jj_2_2(7)) {
176           PackageBody();
177         } else if (jj_2_3(6)) {
178           TypeSpecification();
179         } else if (jj_2_4(6)) {
180           Table();
181         } else if (jj_2_5(6)) {
182           View();
183         } else if (jj_2_6(6)) {
184           TriggerUnit();
185         } else if (jj_2_7(6)) {
186           AlterTrigger();
187         } else if (jj_2_8(6)) {
188           Synonym();
189         } else if (jj_2_9(6)) {
190           Directory();
191         } else if (jj_2_10(6)) {
192           DatabaseLink();
193         } else if (jj_2_11(6)) {
194           Global();
195         } else if (jj_2_12(6)) {
196           DDLCommand();
197         } else if (jj_2_13(2)) {
198           SqlPlusCommand();
199         } else {
200           switch (jj_nt.kind) {
201           case COMMIT:
202           case DELETE:
203           case INSERT:
204           case LOCK:
205           case MERGE:
206           case ROLLBACK:
207           case SAVEPOINT:
208           case SELECT:
209           case UPDATE:
210           case WITH:
211             switch (jj_nt.kind) {
212             case SELECT:
213               jj_consume_token(SELECT);
214               break;
215             case UPDATE:
216               jj_consume_token(UPDATE);
217               break;
218             case INSERT:
219               jj_consume_token(INSERT);
220               break;
221             case DELETE:
222               jj_consume_token(DELETE);
223               break;
224             case COMMIT:
225               jj_consume_token(COMMIT);
226               break;
227             case ROLLBACK:
228               jj_consume_token(ROLLBACK);
229               break;
230             case SAVEPOINT:
231               jj_consume_token(SAVEPOINT);
232               break;
233             case LOCK:
234               jj_consume_token(LOCK);
235               jj_consume_token(TABLE);
236               break;
237             case MERGE:
238               jj_consume_token(MERGE);
239               break;
240             case WITH:
241               jj_consume_token(WITH);
242               break;
243             default:
244               jj_la1[1] = jj_gen;
245               jj_consume_token(-1);
246               throw new ParseException();
247             }
248             SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249             break;
250           default:
251             jj_la1[2] = jj_gen;
252             jj_consume_token(-1);
253             throw new ParseException();
254           }
255         }
256         label_2:
257         while (true) {
258           switch (jj_nt.kind) {
259           case 1:
260             ;
261             break;
262           default:
263             jj_la1[3] = jj_gen;
264             break label_2;
265           }
266           jj_consume_token(1);
267         }
268       }
269       jj_consume_token(0);
270         jjtree.closeNodeScope(jjtn000, true);
271         jjtc000 = false;
272         {if (true) return jjtn000 ;}
273     } catch (Throwable jjte000) {
274           if (jjtc000) {
275             jjtree.clearNodeScope(jjtn000);
276             jjtc000 = false;
277           } else {
278             jjtree.popNode();
279           }
280           if (jjte000 instanceof RuntimeException) {
281             {if (true) throw (RuntimeException)jjte000;}
282           }
283           if (jjte000 instanceof ParseException) {
284             {if (true) throw (ParseException)jjte000;}
285           }
286           {if (true) throw (Error)jjte000;}
287     } finally {
288           if (jjtc000) {
289             jjtree.closeNodeScope(jjtn000, true);
290           }
291     }
292     throw new Error("Missing return statement in function");
293   }
294 
295   final public ASTDDLCommand DDLCommand() throws ParseException {
296  /*@bgen(jjtree) DDLCommand */
297  ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298  boolean jjtc000 = true;
299  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300     try {
301       simpleNode = DDLEvent();
302       SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303     jjtree.closeNodeScope(jjtn000, true);
304     jjtc000 = false;
305     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
306     } catch (Throwable jjte000) {
307     if (jjtc000) {
308       jjtree.clearNodeScope(jjtn000);
309       jjtc000 = false;
310     } else {
311       jjtree.popNode();
312     }
313     if (jjte000 instanceof RuntimeException) {
314       {if (true) throw (RuntimeException)jjte000;}
315     }
316     if (jjte000 instanceof ParseException) {
317       {if (true) throw (ParseException)jjte000;}
318     }
319     {if (true) throw (Error)jjte000;}
320     } finally {
321     if (jjtc000) {
322       jjtree.closeNodeScope(jjtn000, true);
323     }
324     }
325     throw new Error("Missing return statement in function");
326   }
327 
328   final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329  /*@bgen(jjtree) SqlPlusCommand */
330  ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331  boolean jjtc000 = true;
332  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333     try {
334       switch (jj_nt.kind) {
335       case 2:
336         jj_consume_token(2);
337         break;
338       case ACCEPT:
339         jj_consume_token(ACCEPT);
340         break;
341       case COLUMN:
342         jj_consume_token(COLUMN);
343         break;
344       case CONNECT:
345         jj_consume_token(CONNECT);
346         break;
347       case COPY:
348         jj_consume_token(COPY);
349         break;
350       case DEFINE:
351         jj_consume_token(DEFINE);
352         break;
353       case DISCONNECT:
354         jj_consume_token(DISCONNECT);
355         break;
356       case EXECUTE:
357         jj_consume_token(EXECUTE);
358         break;
359       case EXIT:
360         jj_consume_token(EXIT);
361         break;
362       case HOST:
363         jj_consume_token(HOST);
364         break;
365       case PRINT:
366         jj_consume_token(PRINT);
367         break;
368       case PROMPT:
369         jj_consume_token(PROMPT);
370         break;
371       case QUIT:
372         jj_consume_token(QUIT);
373         break;
374       case REMARK:
375         jj_consume_token(REMARK);
376         break;
377       case SET:
378         jj_consume_token(SET);
379         break;
380       case SHOW:
381         jj_consume_token(SHOW);
382         break;
383       case SPOOL:
384         jj_consume_token(SPOOL);
385         break;
386       case START:
387         jj_consume_token(START);
388         break;
389       case UNDEFINE:
390         jj_consume_token(UNDEFINE);
391         break;
392       case VARIABLE:
393         jj_consume_token(VARIABLE);
394         break;
395       case WHENEVER:
396         jj_consume_token(WHENEVER);
397         break;
398       case COMMENT:
399         jj_consume_token(COMMENT);
400         break;
401       case GRANT:
402         jj_consume_token(GRANT);
403         break;
404       case REVOKE:
405         jj_consume_token(REVOKE);
406         break;
407       case DROP:
408         jj_consume_token(DROP);
409         break;
410       case IDENTIFIER:
411         jj_consume_token(IDENTIFIER);
412         break;
413       case 3:
414         jj_consume_token(3);
415         jj_consume_token(ATTACH);
416         break;
417       default:
418         jj_la1[4] = jj_gen;
419         jj_consume_token(-1);
420         throw new ParseException();
421       }
422     sb.append(token.image) ; sb.append(" ...") ;
423       Skip2NextTokenOccurrence(EOL);
424     jjtree.closeNodeScope(jjtn000, true);
425     jjtc000 = false;
426     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
427     } catch (Throwable jjte000) {
428     if (jjtc000) {
429       jjtree.clearNodeScope(jjtn000);
430       jjtc000 = false;
431     } else {
432       jjtree.popNode();
433     }
434     if (jjte000 instanceof RuntimeException) {
435       {if (true) throw (RuntimeException)jjte000;}
436     }
437     if (jjte000 instanceof ParseException) {
438       {if (true) throw (ParseException)jjte000;}
439     }
440     {if (true) throw (Error)jjte000;}
441     } finally {
442     if (jjtc000) {
443       jjtree.closeNodeScope(jjtn000, true);
444     }
445     }
446     throw new Error("Missing return statement in function");
447   }
448 
449 /*
450 SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
451 void attachLibrary() :
452 {}
453 {
454 	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
455 }
456 */
457 
458 /**
459  * All global definitions of triggers, functions and procedures are evaluated here.
460  * Every occurence goes under a new PACKAGE-Node in the XML document.
461  * This happens, cause a global "block" does not have a definied start and end token 
462  * like a package specification or a package body.
463  * Thats why every construct is handled like a new part of the global package.
464  * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
465  * and slow down the whole parsing.
466  * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
467  * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
468  * choose the correct way on a given base. So we can't negate it easily.
469  * On the other hand I could also hold the global state in a global variable. 
470  * But this does not seems the correct way to solve the problem, I think.
471  *
472  * 2006-05-17 - Matthias Hendler - added
473  */
474   final public ASTGlobal Global() throws ParseException {
475  /*@bgen(jjtree) Global */
476   ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477   boolean jjtc000 = true;
478   jjtree.openNodeScope(jjtn000);
479     try {
480       if (jj_2_14(2147483647)) {
481         label_3:
482         while (true) {
483           switch (jj_nt.kind) {
484           case 21:
485             ;
486             break;
487           default:
488             jj_la1[5] = jj_gen;
489             break label_3;
490           }
491           Label();
492         }
493         Block();
494         jj_consume_token(4);
495       } else if (jj_2_15(4)) {
496         ProgramUnit();
497       } else {
498         jj_consume_token(-1);
499         throw new ParseException();
500       }
501         jjtree.closeNodeScope(jjtn000, true);
502         jjtc000 = false;
503         {if (true) return jjtn000 ;}
504     } catch (Throwable jjte000) {
505           if (jjtc000) {
506             jjtree.clearNodeScope(jjtn000);
507             jjtc000 = false;
508           } else {
509             jjtree.popNode();
510           }
511           if (jjte000 instanceof RuntimeException) {
512             {if (true) throw (RuntimeException)jjte000;}
513           }
514           if (jjte000 instanceof ParseException) {
515             {if (true) throw (ParseException)jjte000;}
516           }
517           {if (true) throw (Error)jjte000;}
518     } finally {
519           if (jjtc000) {
520             jjtree.closeNodeScope(jjtn000, true);
521           }
522     }
523     throw new Error("Missing return statement in function");
524   }
525 
526   final public ASTBlock Block() throws ParseException {
527  /*@bgen(jjtree) Block */
528   ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529   boolean jjtc000 = true;
530   jjtree.openNodeScope(jjtn000);
531     try {
532       switch (jj_nt.kind) {
533       case DECLARE:
534         jj_consume_token(DECLARE);
535         DeclarativeSection();
536         break;
537       default:
538         jj_la1[6] = jj_gen;
539         ;
540       }
541       jj_consume_token(BEGIN);
542       label_4:
543       while (true) {
544         switch (jj_nt.kind) {
545         case 5:
546         case 16:
547         case 17:
548         case 21:
549         case REPLACE:
550         case DEFINER:
551         case CURRENT_USER:
552         case LANGUAGE:
553         case INLINE:
554         case ADD:
555         case AGGREGATE:
556         case ARRAY:
557         case AT:
558         case ATTRIBUTE:
559         case AUTHID:
560         case BEGIN:
561         case BODY:
562         case BULK:
563         case BYTE:
564         case CASCADE:
565         case CASE:
566         case CLOSE:
567         case COALESCE:
568         case COLLECT:
569         case COLUMN:
570         case COMMENT:
571         case COMMIT:
572         case CONSTRUCTOR:
573         case CONTINUE:
574         case CONVERT:
575         case CURRENT:
576         case CURSOR:
577         case DATA:
578         case DATE:
579         case DAY:
580         case DECLARE:
581         case DELETE:
582         case DISABLE:
583         case EDITIONABLE:
584         case ELEMENT:
585         case ENABLE:
586         case ESCAPE:
587         case EXCEPT:
588         case EXCEPTIONS:
589         case EXECUTE:
590         case EXIT:
591         case EXTERNAL:
592         case EXTENDS:
593         case EXTRACT:
594         case FALSE:
595         case FETCH:
596         case FINAL:
597         case FOR:
598         case FORALL:
599         case FORCE:
600         case FUNCTION:
601         case GLOBAL:
602         case GOTO:
603         case HASH:
604         case HEAP:
605         case HOUR:
606         case IF:
607         case IMMEDIATE:
608         case INDICES:
609         case INDEXTYPE:
610         case INDICATOR:
611         case INSERT:
612         case INSTANTIABLE:
613         case INTERVAL:
614         case INVALIDATE:
615         case ISOLATION:
616         case JAVA:
617         case LEVEL:
618         case LIMIT:
619         case LOCK:
620         case LOOP:
621         case MAP:
622         case MAX:
623         case MEMBER:
624         case MERGE:
625         case MIN:
626         case MINUTE:
627         case MLSLABEL:
628         case MODIFY:
629         case MOD:
630         case MONTH:
631         case NATURAL:
632         case NEW:
633         case NEW_DOT:
634         case NO:
635         case NONEDITIONABLE:
636         case NOT:
637         case NULL:
638         case NULLIF:
639         case OBJECT:
640         case OID:
641         case OPAQUE:
642         case OPEN:
643         case OPERATOR:
644         case ORGANIZATION:
645         case OTHERS:
646         case OVERRIDING:
647         case PACKAGE:
648         case PARTITION:
649         case PIPE:
650         case PRAGMA:
651         case PRESERVE:
652         case PRIVATE:
653         case PROCEDURE:
654         case RAISE:
655         case RANGE:
656         case RAW:
657         case REAL:
658         case RECORD:
659         case REF:
660         case RELEASE:
661         case RELIES_ON:
662         case RENAME:
663         case RESULT:
664         case RETURN:
665         case RETURNING:
666         case REVERSE:
667         case ROLLBACK:
668         case ROW:
669         case ROWS:
670         case ROWID:
671         case ROWNUM:
672         case SAVE:
673         case SAVEPOINT:
674         case SECOND:
675         case SELECT:
676         case SELF:
677         case SET:
678         case SPACE:
679         case SQL:
680         case SQLCODE:
681         case SQLERRM:
682         case STATIC:
683         case SUBTYPE:
684         case SUBSTITUTABLE:
685         case SUCCESSFUL:
686         case SYSDATE:
687         case SYS_REFCURSOR:
688         case TEMPORARY:
689         case TIME:
690         case TIMESTAMP:
691         case TIMEZONE_REGION:
692         case TIMEZONE_ABBR:
693         case TIMEZONE_MINUTE:
694         case TIMEZONE_HOUR:
695         case TRANSACTION:
696         case TRUE:
697         case TYPE:
698         case UNDER:
699         case USING:
700         case WHILE:
701         case YES:
702         case SHOW:
703         case A:
704         case UPDATE:
705         case DOUBLE:
706         case DEC:
707         case PRECISION:
708         case INT:
709         case NUMERIC:
710         case NCHAR:
711         case NVARCHAR2:
712         case STRING:
713         case UROWID:
714         case VARRAY:
715         case VARYING:
716         case BFILE:
717         case BLOB:
718         case CLOB:
719         case NCLOB:
720         case YEAR:
721         case LOCAL:
722         case WITH:
723         case ZONE:
724         case CHARACTER:
725         case AFTER:
726         case BEFORE:
727         case OLD:
728         case PARENT:
729         case CC_IF:
730         case CC_ERROR:
731         case ANALYZE:
732         case ASSOCIATE:
733         case AUDIT:
734         case COMPOUND:
735         case DATABASE:
736         case CALL:
737         case DDL:
738         case DISASSOCIATE:
739         case EACH:
740         case FOLLOWS:
741         case LOGOFF:
742         case LOGON:
743         case NESTED:
744         case NOAUDIT:
745         case SCHEMA:
746         case SERVERERROR:
747         case SHUTDOWN:
748         case STARTUP:
749         case STATEMENT:
750         case STATISTICS:
751         case SUSPEND:
752         case TRUNCATE:
753         case WRAPPED:
754         case LIBRARY:
755         case NAME:
756         case STRUCT:
757         case CONTEXT:
758         case PARAMETERS:
759         case LENGTH:
760         case TDO:
761         case MAXLEN:
762         case CHARSETID:
763         case CHARSETFORM:
764         case ACCEPT:
765         case ACCESSIBLE:
766         case COPY:
767         case DEFINE:
768         case DISCONNECT:
769         case HOST:
770         case PRINT:
771         case QUIT:
772         case REMARK:
773         case UNDEFINE:
774         case VARIABLE:
775         case WHENEVER:
776         case ATTACH:
777         case CAST:
778         case TREAT:
779         case TRIM:
780         case LEFT:
781         case RIGHT:
782         case BOTH:
783         case EMPTY:
784         case MULTISET:
785         case SUBMULTISET:
786         case LEADING:
787         case TRAILING:
788         case CHAR_CS:
789         case NCHAR_CS:
790         case DBTIMEZONE:
791         case SESSIONTIMEZONE:
792         case AUTHENTICATED:
793         case LINK:
794         case SHARED:
795         case DIRECTORY:
796         case USER:
797         case IDENTIFIER:
798         case UNSIGNED_NUMERIC_LITERAL:
799         case CHARACTER_LITERAL:
800         case STRING_LITERAL:
801         case QUOTED_LITERAL:
802           ;
803           break;
804         default:
805           jj_la1[7] = jj_gen;
806           break label_4;
807         }
808         Statement();
809       }
810       switch (jj_nt.kind) {
811       case EXCEPTION:
812         ExceptionHandler();
813         break;
814       default:
815         jj_la1[8] = jj_gen;
816         ;
817       }
818       jj_consume_token(END);
819       switch (jj_nt.kind) {
820       case IDENTIFIER:
821         jj_consume_token(IDENTIFIER);
822         break;
823       default:
824         jj_la1[9] = jj_gen;
825         ;
826       }
827       jjtree.closeNodeScope(jjtn000, true);
828       jjtc000 = false;
829       {if (true) return jjtn000 ;}
830     } catch (Throwable jjte000) {
831       if (jjtc000) {
832         jjtree.clearNodeScope(jjtn000);
833         jjtc000 = false;
834       } else {
835         jjtree.popNode();
836       }
837       if (jjte000 instanceof RuntimeException) {
838         {if (true) throw (RuntimeException)jjte000;}
839       }
840       if (jjte000 instanceof ParseException) {
841         {if (true) throw (ParseException)jjte000;}
842       }
843       {if (true) throw (Error)jjte000;}
844     } finally {
845       if (jjtc000) {
846         jjtree.closeNodeScope(jjtn000, true);
847       }
848     }
849     throw new Error("Missing return statement in function");
850   }
851 
852   final public ASTPackageSpecification PackageSpecification() throws ParseException {
853  /*@bgen(jjtree) PackageSpecification */
854  ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855  boolean jjtc000 = true;
856  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857     try {
858       switch (jj_nt.kind) {
859       case CREATE:
860         jj_consume_token(CREATE);
861         switch (jj_nt.kind) {
862         case OR:
863           jj_consume_token(OR);
864           jj_consume_token(REPLACE);
865           break;
866         default:
867           jj_la1[10] = jj_gen;
868           ;
869         }
870         switch (jj_nt.kind) {
871         case EDITIONABLE:
872         case NONEDITIONABLE:
873           switch (jj_nt.kind) {
874           case EDITIONABLE:
875             jj_consume_token(EDITIONABLE);
876             break;
877           case NONEDITIONABLE:
878             jj_consume_token(NONEDITIONABLE);
879             break;
880           default:
881             jj_la1[11] = jj_gen;
882             jj_consume_token(-1);
883             throw new ParseException();
884           }
885           break;
886         default:
887           jj_la1[12] = jj_gen;
888           ;
889         }
890         break;
891       default:
892         jj_la1[13] = jj_gen;
893         ;
894       }
895       jj_consume_token(PACKAGE);
896       simpleNode = ObjectNameDeclaration();
897       label_5:
898       while (true) {
899         switch (jj_nt.kind) {
900         case AUTHID:
901         case ACCESSIBLE:
902           ;
903           break;
904         default:
905           jj_la1[14] = jj_gen;
906           break label_5;
907         }
908         switch (jj_nt.kind) {
909         case AUTHID:
910           jj_consume_token(AUTHID);
911           switch (jj_nt.kind) {
912           case CURRENT_USER:
913             jj_consume_token(CURRENT_USER);
914             break;
915           case DEFINER:
916             jj_consume_token(DEFINER);
917             break;
918           default:
919             jj_la1[15] = jj_gen;
920             jj_consume_token(-1);
921             throw new ParseException();
922           }
923           break;
924         case ACCESSIBLE:
925           AccessibleByClause();
926           break;
927         default:
928           jj_la1[16] = jj_gen;
929           jj_consume_token(-1);
930           throw new ParseException();
931         }
932       }
933       switch (jj_nt.kind) {
934       case WRAPPED:
935         WrappedObject();
936         break;
937       case AS:
938       case IS:
939         switch (jj_nt.kind) {
940         case IS:
941           jj_consume_token(IS);
942           break;
943         case AS:
944           jj_consume_token(AS);
945           break;
946         default:
947           jj_la1[17] = jj_gen;
948           jj_consume_token(-1);
949           throw new ParseException();
950         }
951         DeclarativeSection();
952         jj_consume_token(END);
953         switch (jj_nt.kind) {
954         case REPLACE:
955         case DEFINER:
956         case CURRENT_USER:
957         case SERIALLY_REUSABLE:
958         case RESTRICT_REFERENCES:
959         case EXCEPTION_INIT:
960         case AUTONOMOUS_TRANSACTION:
961         case LANGUAGE:
962         case INLINE:
963         case ADD:
964         case AGGREGATE:
965         case ALL:
966         case ALTER:
967         case AND:
968         case ANY:
969         case ARRAY:
970         case AS:
971         case ASC:
972         case AT:
973         case ATTRIBUTE:
974         case AUTHID:
975         case AVG:
976         case BETWEEN:
977         case BINARY_INTEGER:
978         case BODY:
979         case BOOLEAN:
980         case BULK:
981         case BY:
982         case BYTE:
983         case CASCADE:
984         case CASE:
985         case CHAR:
986         case CHAR_BASE:
987         case CHECK:
988         case CLOSE:
989         case CLUSTER:
990         case COALESCE:
991         case COLLECT:
992         case COLUMN:
993         case COMMENT:
994         case COMMIT:
995         case COMPRESS:
996         case CONNECT:
997         case CONSTANT:
998         case CONSTRUCTOR:
999         case CONTINUE:
1000         case CONVERT:
1001         case CREATE:
1002         case CURRENT:
1003         case CURRVAL:
1004         case CURSOR:
1005         case DATA:
1006         case DATE:
1007         case DAY:
1008         case DECLARE:
1009         case DECIMAL:
1010         case _DEFAULT:
1011         case DELETE:
1012         case DESC:
1013         case DISABLE:
1014         case DISTINCT:
1015         case DO:
1016         case DROP:
1017         case EDITIONABLE:
1018         case ELEMENT:
1019         case ELSE:
1020         case ELSIF:
1021         case ENABLE:
1022         case ESCAPE:
1023         case EXCEPT:
1024         case EXCEPTION:
1025         case EXCEPTIONS:
1026         case EXCLUSIVE:
1027         case EXECUTE:
1028         case EXISTS:
1029         case EXIT:
1030         case EXTERNAL:
1031         case EXTENDS:
1032         case EXTRACT:
1033         case FALSE:
1034         case FETCH:
1035         case FINAL:
1036         case FLOAT:
1037         case FOR:
1038         case FORALL:
1039         case FORCE:
1040         case FROM:
1041         case FUNCTION:
1042         case GLOBAL:
1043         case GOTO:
1044         case GROUP:
1045         case HASH:
1046         case HAVING:
1047         case HEAP:
1048         case HOUR:
1049         case IF:
1050         case IMMEDIATE:
1051         case IN:
1052         case INDEX:
1053         case INDICES:
1054         case INDEXTYPE:
1055         case INDICATOR:
1056         case INSERT:
1057         case INSTANTIABLE:
1058         case INTEGER:
1059         case INTERFACE:
1060         case INTERSECT:
1061         case INTERVAL:
1062         case INTO:
1063         case INVALIDATE:
1064         case IS:
1065         case ISOLATION:
1066         case JAVA:
1067         case LEVEL:
1068         case LIKE:
1069         case LIMIT:
1070         case LIMITED:
1071         case LOCK:
1072         case LONG:
1073         case LOOP:
1074         case MAP:
1075         case MAX:
1076         case MEMBER:
1077         case MERGE:
1078         case MIN:
1079         case MINUS:
1080         case MINUTE:
1081         case MLSLABEL:
1082         case MODIFY:
1083         case MOD:
1084         case MODE:
1085         case MONTH:
1086         case NATURAL:
1087         case NATURALN:
1088         case NEW:
1089         case NEXTVAL:
1090         case NO:
1091         case NOCOPY:
1092         case NONEDITIONABLE:
1093         case NOT:
1094         case NOWAIT:
1095         case NULL:
1096         case NULLIF:
1097         case NUMBER:
1098         case BFILE_BASE:
1099         case BLOB_BASE:
1100         case CLOB_BASE:
1101         case DATE_BASE:
1102         case NUMBER_BASE:
1103         case OBJECT:
1104         case OCIROWID:
1105         case OF:
1106         case OID:
1107         case ON:
1108         case OPAQUE:
1109         case OPEN:
1110         case OPERATOR:
1111         case OPTION:
1112         case OR:
1113         case ORDER:
1114         case ORGANIZATION:
1115         case OTHERS:
1116         case OUT:
1117         case OVERRIDING:
1118         case PACKAGE:
1119         case PARTITION:
1120         case PCTFREE:
1121         case PLS_INTEGER:
1122         case POSITIVE:
1123         case POSITIVEN:
1124         case PRESERVE:
1125         case PRIOR:
1126         case PROMPT:
1127         case PRIVATE:
1128         case PROCEDURE:
1129         case PUBLIC:
1130         case RAISE:
1131         case RANGE:
1132         case RAW:
1133         case REAL:
1134         case RECORD:
1135         case REF:
1136         case RELEASE:
1137         case RELIES_ON:
1138         case RENAME:
1139         case RESULT:
1140         case RETURN:
1141         case RETURNING:
1142         case REVERSE:
1143         case ROLLBACK:
1144         case ROW:
1145         case ROWS:
1146         case ROWID:
1147         case ROWNUM:
1148         case ROWTYPE:
1149         case SAVE:
1150         case SAVEPOINT:
1151         case SECOND:
1152         case SELECT:
1153         case SELF:
1154         case SEPARATE:
1155         case SET:
1156         case SHARE:
1157         case SMALLINT:
1158         case SPACE:
1159         case SQL:
1160         case SQLCODE:
1161         case SQLERRM:
1162         case START:
1163         case STATIC:
1164         case STDDEV:
1165         case SUBTYPE:
1166         case SUBSTITUTABLE:
1167         case SUCCESSFUL:
1168         case SUM:
1169         case SYNONYM:
1170         case SYSDATE:
1171         case SYS_REFCURSOR:
1172         case TABLE:
1173         case TEMPORARY:
1174         case THEN:
1175         case TIME:
1176         case TIMESTAMP:
1177         case TIMEZONE_REGION:
1178         case TIMEZONE_ABBR:
1179         case TIMEZONE_MINUTE:
1180         case TIMEZONE_HOUR:
1181         case TO:
1182         case TRANSACTION:
1183         case TRIGGER:
1184         case TRUE:
1185         case TYPE:
1186         case UI:
1187         case UNDER:
1188         case USING:
1189         case WHILE:
1190         case YES:
1191         case SHOW:
1192         case A:
1193         case UPDATE:
1194         case VARCHAR:
1195         case VARCHAR2:
1196         case DOUBLE:
1197         case DEC:
1198         case PRECISION:
1199         case INT:
1200         case NUMERIC:
1201         case SIGNTYPE:
1202         case NCHAR:
1203         case NVARCHAR2:
1204         case STRING:
1205         case UROWID:
1206         case VARRAY:
1207         case VARYING:
1208         case BFILE:
1209         case BLOB:
1210         case CLOB:
1211         case NCLOB:
1212         case YEAR:
1213         case LOCAL:
1214         case WITH:
1215         case ZONE:
1216         case CHARACTER:
1217         case AFTER:
1218         case BEFORE:
1219         case OLD:
1220         case PARENT:
1221         case ANALYZE:
1222         case ASSOCIATE:
1223         case AUDIT:
1224         case COMPOUND:
1225         case DATABASE:
1226         case CALL:
1227         case DDL:
1228         case DISASSOCIATE:
1229         case EACH:
1230         case FOLLOWS:
1231         case LOGOFF:
1232         case LOGON:
1233         case NESTED:
1234         case NOAUDIT:
1235         case SCHEMA:
1236         case SERVERERROR:
1237         case SHUTDOWN:
1238         case STARTUP:
1239         case STATEMENT:
1240         case STATISTICS:
1241         case SUSPEND:
1242         case TRUNCATE:
1243         case WRAPPED:
1244         case LIBRARY:
1245         case NAME:
1246         case STRUCT:
1247         case CONTEXT:
1248         case PARAMETERS:
1249         case LENGTH:
1250         case TDO:
1251         case MAXLEN:
1252         case CHARSETID:
1253         case CHARSETFORM:
1254         case ACCEPT:
1255         case ACCESSIBLE:
1256         case COPY:
1257         case DEFINE:
1258         case DISCONNECT:
1259         case HOST:
1260         case PRINT:
1261         case QUIT:
1262         case REMARK:
1263         case UNDEFINE:
1264         case VARIABLE:
1265         case WHENEVER:
1266         case ATTACH:
1267         case CAST:
1268         case TREAT:
1269         case TRIM:
1270         case LEFT:
1271         case RIGHT:
1272         case BOTH:
1273         case EMPTY:
1274         case MULTISET:
1275         case SUBMULTISET:
1276         case LEADING:
1277         case TRAILING:
1278         case CHAR_CS:
1279         case NCHAR_CS:
1280         case DBTIMEZONE:
1281         case SESSIONTIMEZONE:
1282         case AUTHENTICATED:
1283         case LINK:
1284         case SHARED:
1285         case DIRECTORY:
1286         case USER:
1287         case IDENTIFIER:
1288         case QUOTED_LITERAL:
1289         case SQLDATA_CLASS:
1290         case CUSTOMDATUM_CLASS:
1291         case ORADATA_CLASS:
1292         case JAVA_INTERFACE_CLASS:
1293           ID();
1294           break;
1295         default:
1296           jj_la1[18] = jj_gen;
1297           ;
1298         }
1299         jj_consume_token(4);
1300         break;
1301       default:
1302         jj_la1[19] = jj_gen;
1303         jj_consume_token(-1);
1304         throw new ParseException();
1305       }
1306         jjtree.closeNodeScope(jjtn000, true);
1307         jjtc000 = false;
1308         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
1309     } catch (Throwable jjte000) {
1310         if (jjtc000) {
1311           jjtree.clearNodeScope(jjtn000);
1312           jjtc000 = false;
1313         } else {
1314           jjtree.popNode();
1315         }
1316         if (jjte000 instanceof RuntimeException) {
1317           {if (true) throw (RuntimeException)jjte000;}
1318         }
1319         if (jjte000 instanceof ParseException) {
1320           {if (true) throw (ParseException)jjte000;}
1321         }
1322         {if (true) throw (Error)jjte000;}
1323     } finally {
1324         if (jjtc000) {
1325           jjtree.closeNodeScope(jjtn000, true);
1326         }
1327     }
1328     throw new Error("Missing return statement in function");
1329   }
1330 
1331   final public ASTPackageBody PackageBody() throws ParseException {
1332  /*@bgen(jjtree) PackageBody */
1333  ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334  boolean jjtc000 = true;
1335  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336     try {
1337       switch (jj_nt.kind) {
1338       case CREATE:
1339         jj_consume_token(CREATE);
1340         switch (jj_nt.kind) {
1341         case OR:
1342           jj_consume_token(OR);
1343           jj_consume_token(REPLACE);
1344           break;
1345         default:
1346           jj_la1[20] = jj_gen;
1347           ;
1348         }
1349         switch (jj_nt.kind) {
1350         case EDITIONABLE:
1351         case NONEDITIONABLE:
1352           switch (jj_nt.kind) {
1353           case EDITIONABLE:
1354             jj_consume_token(EDITIONABLE);
1355             break;
1356           case NONEDITIONABLE:
1357             jj_consume_token(NONEDITIONABLE);
1358             break;
1359           default:
1360             jj_la1[21] = jj_gen;
1361             jj_consume_token(-1);
1362             throw new ParseException();
1363           }
1364           break;
1365         default:
1366           jj_la1[22] = jj_gen;
1367           ;
1368         }
1369         break;
1370       default:
1371         jj_la1[23] = jj_gen;
1372         ;
1373       }
1374       switch (jj_nt.kind) {
1375       case PACKAGE:
1376         jj_consume_token(PACKAGE);
1377         break;
1378       case TYPE:
1379         jj_consume_token(TYPE);
1380         break;
1381       default:
1382         jj_la1[24] = jj_gen;
1383         jj_consume_token(-1);
1384         throw new ParseException();
1385       }
1386       jj_consume_token(BODY);
1387       simpleNode = ObjectNameDeclaration();
1388       switch (jj_nt.kind) {
1389       case WRAPPED:
1390         WrappedObject();
1391         break;
1392       case AS:
1393       case IS:
1394         switch (jj_nt.kind) {
1395         case IS:
1396           jj_consume_token(IS);
1397           break;
1398         case AS:
1399           jj_consume_token(AS);
1400           break;
1401         default:
1402           jj_la1[25] = jj_gen;
1403           jj_consume_token(-1);
1404           throw new ParseException();
1405         }
1406         DeclarativeSection();
1407         switch (jj_nt.kind) {
1408         case BEGIN:
1409           jj_consume_token(BEGIN);
1410           label_6:
1411           while (true) {
1412             switch (jj_nt.kind) {
1413             case 5:
1414             case 16:
1415             case 17:
1416             case 21:
1417             case REPLACE:
1418             case DEFINER:
1419             case CURRENT_USER:
1420             case LANGUAGE:
1421             case INLINE:
1422             case ADD:
1423             case AGGREGATE:
1424             case ARRAY:
1425             case AT:
1426             case ATTRIBUTE:
1427             case AUTHID:
1428             case BEGIN:
1429             case BODY:
1430             case BULK:
1431             case BYTE:
1432             case CASCADE:
1433             case CASE:
1434             case CLOSE:
1435             case COALESCE:
1436             case COLLECT:
1437             case COLUMN:
1438             case COMMENT:
1439             case COMMIT:
1440             case CONSTRUCTOR:
1441             case CONTINUE:
1442             case CONVERT:
1443             case CURRENT:
1444             case CURSOR:
1445             case DATA:
1446             case DATE:
1447             case DAY:
1448             case DECLARE:
1449             case DELETE:
1450             case DISABLE:
1451             case EDITIONABLE:
1452             case ELEMENT:
1453             case ENABLE:
1454             case ESCAPE:
1455             case EXCEPT:
1456             case EXCEPTIONS:
1457             case EXECUTE:
1458             case EXIT:
1459             case EXTERNAL:
1460             case EXTENDS:
1461             case EXTRACT:
1462             case FALSE:
1463             case FETCH:
1464             case FINAL:
1465             case FOR:
1466             case FORALL:
1467             case FORCE:
1468             case FUNCTION:
1469             case GLOBAL:
1470             case GOTO:
1471             case HASH:
1472             case HEAP:
1473             case HOUR:
1474             case IF:
1475             case IMMEDIATE:
1476             case INDICES:
1477             case INDEXTYPE:
1478             case INDICATOR:
1479             case INSERT:
1480             case INSTANTIABLE:
1481             case INTERVAL:
1482             case INVALIDATE:
1483             case ISOLATION:
1484             case JAVA:
1485             case LEVEL:
1486             case LIMIT:
1487             case LOCK:
1488             case LOOP:
1489             case MAP:
1490             case MAX:
1491             case MEMBER:
1492             case MERGE:
1493             case MIN:
1494             case MINUTE:
1495             case MLSLABEL:
1496             case MODIFY:
1497             case MOD:
1498             case MONTH:
1499             case NATURAL:
1500             case NEW:
1501             case NEW_DOT:
1502             case NO:
1503             case NONEDITIONABLE:
1504             case NOT:
1505             case NULL:
1506             case NULLIF:
1507             case OBJECT:
1508             case OID:
1509             case OPAQUE:
1510             case OPEN:
1511             case OPERATOR:
1512             case ORGANIZATION:
1513             case OTHERS:
1514             case OVERRIDING:
1515             case PACKAGE:
1516             case PARTITION:
1517             case PIPE:
1518             case PRAGMA:
1519             case PRESERVE:
1520             case PRIVATE:
1521             case PROCEDURE:
1522             case RAISE:
1523             case RANGE:
1524             case RAW:
1525             case REAL:
1526             case RECORD:
1527             case REF:
1528             case RELEASE:
1529             case RELIES_ON:
1530             case RENAME:
1531             case RESULT:
1532             case RETURN:
1533             case RETURNING:
1534             case REVERSE:
1535             case ROLLBACK:
1536             case ROW:
1537             case ROWS:
1538             case ROWID:
1539             case ROWNUM:
1540             case SAVE:
1541             case SAVEPOINT:
1542             case SECOND:
1543             case SELECT:
1544             case SELF:
1545             case SET:
1546             case SPACE:
1547             case SQL:
1548             case SQLCODE:
1549             case SQLERRM:
1550             case STATIC:
1551             case SUBTYPE:
1552             case SUBSTITUTABLE:
1553             case SUCCESSFUL:
1554             case SYSDATE:
1555             case SYS_REFCURSOR:
1556             case TEMPORARY:
1557             case TIME:
1558             case TIMESTAMP:
1559             case TIMEZONE_REGION:
1560             case TIMEZONE_ABBR:
1561             case TIMEZONE_MINUTE:
1562             case TIMEZONE_HOUR:
1563             case TRANSACTION:
1564             case TRUE:
1565             case TYPE:
1566             case UNDER:
1567             case USING:
1568             case WHILE:
1569             case YES:
1570             case SHOW:
1571             case A:
1572             case UPDATE:
1573             case DOUBLE:
1574             case DEC:
1575             case PRECISION:
1576             case INT:
1577             case NUMERIC:
1578             case NCHAR:
1579             case NVARCHAR2:
1580             case STRING:
1581             case UROWID:
1582             case VARRAY:
1583             case VARYING:
1584             case BFILE:
1585             case BLOB:
1586             case CLOB:
1587             case NCLOB:
1588             case YEAR:
1589             case LOCAL:
1590             case WITH:
1591             case ZONE:
1592             case CHARACTER:
1593             case AFTER:
1594             case BEFORE:
1595             case OLD:
1596             case PARENT:
1597             case CC_IF:
1598             case CC_ERROR:
1599             case ANALYZE:
1600             case ASSOCIATE:
1601             case AUDIT:
1602             case COMPOUND:
1603             case DATABASE:
1604             case CALL:
1605             case DDL:
1606             case DISASSOCIATE:
1607             case EACH:
1608             case FOLLOWS:
1609             case LOGOFF:
1610             case LOGON:
1611             case NESTED:
1612             case NOAUDIT:
1613             case SCHEMA:
1614             case SERVERERROR:
1615             case SHUTDOWN:
1616             case STARTUP:
1617             case STATEMENT:
1618             case STATISTICS:
1619             case SUSPEND:
1620             case TRUNCATE:
1621             case WRAPPED:
1622             case LIBRARY:
1623             case NAME:
1624             case STRUCT:
1625             case CONTEXT:
1626             case PARAMETERS:
1627             case LENGTH:
1628             case TDO:
1629             case MAXLEN:
1630             case CHARSETID:
1631             case CHARSETFORM:
1632             case ACCEPT:
1633             case ACCESSIBLE:
1634             case COPY:
1635             case DEFINE:
1636             case DISCONNECT:
1637             case HOST:
1638             case PRINT:
1639             case QUIT:
1640             case REMARK:
1641             case UNDEFINE:
1642             case VARIABLE:
1643             case WHENEVER:
1644             case ATTACH:
1645             case CAST:
1646             case TREAT:
1647             case TRIM:
1648             case LEFT:
1649             case RIGHT:
1650             case BOTH:
1651             case EMPTY:
1652             case MULTISET:
1653             case SUBMULTISET:
1654             case LEADING:
1655             case TRAILING:
1656             case CHAR_CS:
1657             case NCHAR_CS:
1658             case DBTIMEZONE:
1659             case SESSIONTIMEZONE:
1660             case AUTHENTICATED:
1661             case LINK:
1662             case SHARED:
1663             case DIRECTORY:
1664             case USER:
1665             case IDENTIFIER:
1666             case UNSIGNED_NUMERIC_LITERAL:
1667             case CHARACTER_LITERAL:
1668             case STRING_LITERAL:
1669             case QUOTED_LITERAL:
1670               ;
1671               break;
1672             default:
1673               jj_la1[26] = jj_gen;
1674               break label_6;
1675             }
1676             Statement();
1677           }
1678           switch (jj_nt.kind) {
1679           case EXCEPTION:
1680             ExceptionHandler();
1681             break;
1682           default:
1683             jj_la1[27] = jj_gen;
1684             ;
1685           }
1686           break;
1687         default:
1688           jj_la1[28] = jj_gen;
1689           ;
1690         }
1691         jj_consume_token(END);
1692         switch (jj_nt.kind) {
1693         case REPLACE:
1694         case DEFINER:
1695         case CURRENT_USER:
1696         case SERIALLY_REUSABLE:
1697         case RESTRICT_REFERENCES:
1698         case EXCEPTION_INIT:
1699         case AUTONOMOUS_TRANSACTION:
1700         case LANGUAGE:
1701         case INLINE:
1702         case ADD:
1703         case AGGREGATE:
1704         case ALL:
1705         case ALTER:
1706         case AND:
1707         case ANY:
1708         case ARRAY:
1709         case AS:
1710         case ASC:
1711         case AT:
1712         case ATTRIBUTE:
1713         case AUTHID:
1714         case AVG:
1715         case BETWEEN:
1716         case BINARY_INTEGER:
1717         case BODY:
1718         case BOOLEAN:
1719         case BULK:
1720         case BY:
1721         case BYTE:
1722         case CASCADE:
1723         case CASE:
1724         case CHAR:
1725         case CHAR_BASE:
1726         case CHECK:
1727         case CLOSE:
1728         case CLUSTER:
1729         case COALESCE:
1730         case COLLECT:
1731         case COLUMN:
1732         case COMMENT:
1733         case COMMIT:
1734         case COMPRESS:
1735         case CONNECT:
1736         case CONSTANT:
1737         case CONSTRUCTOR:
1738         case CONTINUE:
1739         case CONVERT:
1740         case CREATE:
1741         case CURRENT:
1742         case CURRVAL:
1743         case CURSOR:
1744         case DATA:
1745         case DATE:
1746         case DAY:
1747         case DECLARE:
1748         case DECIMAL:
1749         case _DEFAULT:
1750         case DELETE:
1751         case DESC:
1752         case DISABLE:
1753         case DISTINCT:
1754         case DO:
1755         case DROP:
1756         case EDITIONABLE:
1757         case ELEMENT:
1758         case ELSE:
1759         case ELSIF:
1760         case ENABLE:
1761         case ESCAPE:
1762         case EXCEPT:
1763         case EXCEPTION:
1764         case EXCEPTIONS:
1765         case EXCLUSIVE:
1766         case EXECUTE:
1767         case EXISTS:
1768         case EXIT:
1769         case EXTERNAL:
1770         case EXTENDS:
1771         case EXTRACT:
1772         case FALSE:
1773         case FETCH:
1774         case FINAL:
1775         case FLOAT:
1776         case FOR:
1777         case FORALL:
1778         case FORCE:
1779         case FROM:
1780         case FUNCTION:
1781         case GLOBAL:
1782         case GOTO:
1783         case GROUP:
1784         case HASH:
1785         case HAVING:
1786         case HEAP:
1787         case HOUR:
1788         case IF:
1789         case IMMEDIATE:
1790         case IN:
1791         case INDEX:
1792         case INDICES:
1793         case INDEXTYPE:
1794         case INDICATOR:
1795         case INSERT:
1796         case INSTANTIABLE:
1797         case INTEGER:
1798         case INTERFACE:
1799         case INTERSECT:
1800         case INTERVAL:
1801         case INTO:
1802         case INVALIDATE:
1803         case IS:
1804         case ISOLATION:
1805         case JAVA:
1806         case LEVEL:
1807         case LIKE:
1808         case LIMIT:
1809         case LIMITED:
1810         case LOCK:
1811         case LONG:
1812         case LOOP:
1813         case MAP:
1814         case MAX:
1815         case MEMBER:
1816         case MERGE:
1817         case MIN:
1818         case MINUS:
1819         case MINUTE:
1820         case MLSLABEL:
1821         case MODIFY:
1822         case MOD:
1823         case MODE:
1824         case MONTH:
1825         case NATURAL:
1826         case NATURALN:
1827         case NEW:
1828         case NEXTVAL:
1829         case NO:
1830         case NOCOPY:
1831         case NONEDITIONABLE:
1832         case NOT:
1833         case NOWAIT:
1834         case NULL:
1835         case NULLIF:
1836         case NUMBER:
1837         case BFILE_BASE:
1838         case BLOB_BASE:
1839         case CLOB_BASE:
1840         case DATE_BASE:
1841         case NUMBER_BASE:
1842         case OBJECT:
1843         case OCIROWID:
1844         case OF:
1845         case OID:
1846         case ON:
1847         case OPAQUE:
1848         case OPEN:
1849         case OPERATOR:
1850         case OPTION:
1851         case OR:
1852         case ORDER:
1853         case ORGANIZATION:
1854         case OTHERS:
1855         case OUT:
1856         case OVERRIDING:
1857         case PACKAGE:
1858         case PARTITION:
1859         case PCTFREE:
1860         case PLS_INTEGER:
1861         case POSITIVE:
1862         case POSITIVEN:
1863         case PRESERVE:
1864         case PRIOR:
1865         case PROMPT:
1866         case PRIVATE:
1867         case PROCEDURE:
1868         case PUBLIC:
1869         case RAISE:
1870         case RANGE:
1871         case RAW:
1872         case REAL:
1873         case RECORD:
1874         case REF:
1875         case RELEASE:
1876         case RELIES_ON:
1877         case RENAME:
1878         case RESULT:
1879         case RETURN:
1880         case RETURNING:
1881         case REVERSE:
1882         case ROLLBACK:
1883         case ROW:
1884         case ROWS:
1885         case ROWID:
1886         case ROWNUM:
1887         case ROWTYPE:
1888         case SAVE:
1889         case SAVEPOINT:
1890         case SECOND:
1891         case SELECT:
1892         case SELF:
1893         case SEPARATE:
1894         case SET:
1895         case SHARE:
1896         case SMALLINT:
1897         case SPACE:
1898         case SQL:
1899         case SQLCODE:
1900         case SQLERRM:
1901         case START:
1902         case STATIC:
1903         case STDDEV:
1904         case SUBTYPE:
1905         case SUBSTITUTABLE:
1906         case SUCCESSFUL:
1907         case SUM:
1908         case SYNONYM:
1909         case SYSDATE:
1910         case SYS_REFCURSOR:
1911         case TABLE:
1912         case TEMPORARY:
1913         case THEN:
1914         case TIME:
1915         case TIMESTAMP:
1916         case TIMEZONE_REGION:
1917         case TIMEZONE_ABBR:
1918         case TIMEZONE_MINUTE:
1919         case TIMEZONE_HOUR:
1920         case TO:
1921         case TRANSACTION:
1922         case TRIGGER:
1923         case TRUE:
1924         case TYPE:
1925         case UI:
1926         case UNDER:
1927         case USING:
1928         case WHILE:
1929         case YES:
1930         case SHOW:
1931         case A:
1932         case UPDATE:
1933         case VARCHAR:
1934         case VARCHAR2:
1935         case DOUBLE:
1936         case DEC:
1937         case PRECISION:
1938         case INT:
1939         case NUMERIC:
1940         case SIGNTYPE:
1941         case NCHAR:
1942         case NVARCHAR2:
1943         case STRING:
1944         case UROWID:
1945         case VARRAY:
1946         case VARYING:
1947         case BFILE:
1948         case BLOB:
1949         case CLOB:
1950         case NCLOB:
1951         case YEAR:
1952         case LOCAL:
1953         case WITH:
1954         case ZONE:
1955         case CHARACTER:
1956         case AFTER:
1957         case BEFORE:
1958         case OLD:
1959         case PARENT:
1960         case ANALYZE:
1961         case ASSOCIATE:
1962         case AUDIT:
1963         case COMPOUND:
1964         case DATABASE:
1965         case CALL:
1966         case DDL:
1967         case DISASSOCIATE:
1968         case EACH:
1969         case FOLLOWS:
1970         case LOGOFF:
1971         case LOGON:
1972         case NESTED:
1973         case NOAUDIT:
1974         case SCHEMA:
1975         case SERVERERROR:
1976         case SHUTDOWN:
1977         case STARTUP:
1978         case STATEMENT:
1979         case STATISTICS:
1980         case SUSPEND:
1981         case TRUNCATE:
1982         case WRAPPED:
1983         case LIBRARY:
1984         case NAME:
1985         case STRUCT:
1986         case CONTEXT:
1987         case PARAMETERS:
1988         case LENGTH:
1989         case TDO:
1990         case MAXLEN:
1991         case CHARSETID:
1992         case CHARSETFORM:
1993         case ACCEPT:
1994         case ACCESSIBLE:
1995         case COPY:
1996         case DEFINE:
1997         case DISCONNECT:
1998         case HOST:
1999         case PRINT:
2000         case QUIT:
2001         case REMARK:
2002         case UNDEFINE:
2003         case VARIABLE:
2004         case WHENEVER:
2005         case ATTACH:
2006         case CAST:
2007         case TREAT:
2008         case TRIM:
2009         case LEFT:
2010         case RIGHT:
2011         case BOTH:
2012         case EMPTY:
2013         case MULTISET:
2014         case SUBMULTISET:
2015         case LEADING:
2016         case TRAILING:
2017         case CHAR_CS:
2018         case NCHAR_CS:
2019         case DBTIMEZONE:
2020         case SESSIONTIMEZONE:
2021         case AUTHENTICATED:
2022         case LINK:
2023         case SHARED:
2024         case DIRECTORY:
2025         case USER:
2026         case IDENTIFIER:
2027         case QUOTED_LITERAL:
2028         case SQLDATA_CLASS:
2029         case CUSTOMDATUM_CLASS:
2030         case ORADATA_CLASS:
2031         case JAVA_INTERFACE_CLASS:
2032           ID();
2033           break;
2034         default:
2035           jj_la1[29] = jj_gen;
2036           ;
2037         }
2038         jj_consume_token(4);
2039         break;
2040       default:
2041         jj_la1[30] = jj_gen;
2042         jj_consume_token(-1);
2043         throw new ParseException();
2044       }
2045       jjtree.closeNodeScope(jjtn000, true);
2046       jjtc000 = false;
2047       jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
2048     } catch (Throwable jjte000) {
2049       if (jjtc000) {
2050         jjtree.clearNodeScope(jjtn000);
2051         jjtc000 = false;
2052       } else {
2053         jjtree.popNode();
2054       }
2055       if (jjte000 instanceof RuntimeException) {
2056         {if (true) throw (RuntimeException)jjte000;}
2057       }
2058       if (jjte000 instanceof ParseException) {
2059         {if (true) throw (ParseException)jjte000;}
2060       }
2061       {if (true) throw (Error)jjte000;}
2062     } finally {
2063       if (jjtc000) {
2064         jjtree.closeNodeScope(jjtn000, true);
2065       }
2066     }
2067     throw new Error("Missing return statement in function");
2068   }
2069 
2070   final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071  /*@bgen(jjtree) DeclarativeUnit */
2072   ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073   boolean jjtc000 = true;
2074   jjtree.openNodeScope(jjtn000);
2075     try {
2076       switch (jj_nt.kind) {
2077       case PRAGMA:
2078         Pragma();
2079         break;
2080       default:
2081         jj_la1[31] = jj_gen;
2082         if (jj_2_16(2)) {
2083           ExceptionDeclaration();
2084         } else if (jj_2_17(2147483647)) {
2085           SubTypeDefinition();
2086         } else if (jj_2_18(2147483647)) {
2087           ProgramUnit();
2088         } else if (jj_2_19(4)) {
2089           VariableOrConstantDeclaration();
2090         } else if (jj_2_20(2)) {
2091           CursorSpecification();
2092         } else {
2093           switch (jj_nt.kind) {
2094           case CURSOR:
2095             CursorBody();
2096             break;
2097           case IDENTIFIER:
2098             CollectionDeclaration();
2099             break;
2100           case CONSTRUCTOR:
2101           case CREATE:
2102           case FINAL:
2103           case FUNCTION:
2104           case INSTANTIABLE:
2105           case MAP:
2106           case MEMBER:
2107           case NOT:
2108           case ORDER:
2109           case OVERRIDING:
2110           case PROCEDURE:
2111           case STATIC:
2112             MethodDeclaration();
2113             break;
2114           case CC_IF:
2115             CompilationDeclarationFragment();
2116             break;
2117           default:
2118             jj_la1[32] = jj_gen;
2119             jj_consume_token(-1);
2120             throw new ParseException();
2121           }
2122         }
2123       }
2124       jjtree.closeNodeScope(jjtn000, true);
2125       jjtc000 = false;
2126       {if (true) return jjtn000 ;}
2127     } catch (Throwable jjte000) {
2128       if (jjtc000) {
2129         jjtree.clearNodeScope(jjtn000);
2130         jjtc000 = false;
2131       } else {
2132         jjtree.popNode();
2133       }
2134       if (jjte000 instanceof RuntimeException) {
2135         {if (true) throw (RuntimeException)jjte000;}
2136       }
2137       if (jjte000 instanceof ParseException) {
2138         {if (true) throw (ParseException)jjte000;}
2139       }
2140       {if (true) throw (Error)jjte000;}
2141     } finally {
2142       if (jjtc000) {
2143         jjtree.closeNodeScope(jjtn000, true);
2144       }
2145     }
2146     throw new Error("Missing return statement in function");
2147   }
2148 
2149   final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150  /*@bgen(jjtree) DeclarativeSection */
2151   ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152   boolean jjtc000 = true;
2153   jjtree.openNodeScope(jjtn000);
2154     try {
2155       label_7:
2156       while (true) {
2157         switch (jj_nt.kind) {
2158         case REPLACE:
2159         case DEFINER:
2160         case CURRENT_USER:
2161         case SERIALLY_REUSABLE:
2162         case RESTRICT_REFERENCES:
2163         case EXCEPTION_INIT:
2164         case AUTONOMOUS_TRANSACTION:
2165         case LANGUAGE:
2166         case INLINE:
2167         case ADD:
2168         case AGGREGATE:
2169         case ALL:
2170         case ALTER:
2171         case AND:
2172         case ANY:
2173         case ARRAY:
2174         case AS:
2175         case ASC:
2176         case AT:
2177         case ATTRIBUTE:
2178         case AUTHID:
2179         case AVG:
2180         case BETWEEN:
2181         case BINARY_INTEGER:
2182         case BODY:
2183         case BOOLEAN:
2184         case BULK:
2185         case BY:
2186         case BYTE:
2187         case CASCADE:
2188         case CASE:
2189         case CHAR:
2190         case CHAR_BASE:
2191         case CHECK:
2192         case CLOSE:
2193         case CLUSTER:
2194         case COALESCE:
2195         case COLLECT:
2196         case COLUMN:
2197         case COMMENT:
2198         case COMMIT:
2199         case COMPRESS:
2200         case CONNECT:
2201         case CONSTANT:
2202         case CONSTRUCTOR:
2203         case CONTINUE:
2204         case CONVERT:
2205         case CREATE:
2206         case CURRENT:
2207         case CURRVAL:
2208         case CURSOR:
2209         case DATA:
2210         case DATE:
2211         case DAY:
2212         case DECLARE:
2213         case DECIMAL:
2214         case _DEFAULT:
2215         case DELETE:
2216         case DESC:
2217         case DISABLE:
2218         case DISTINCT:
2219         case DO:
2220         case DROP:
2221         case EDITIONABLE:
2222         case ELEMENT:
2223         case ELSE:
2224         case ELSIF:
2225         case ENABLE:
2226         case ESCAPE:
2227         case EXCEPT:
2228         case EXCEPTION:
2229         case EXCEPTIONS:
2230         case EXCLUSIVE:
2231         case EXECUTE:
2232         case EXISTS:
2233         case EXIT:
2234         case EXTERNAL:
2235         case EXTENDS:
2236         case EXTRACT:
2237         case FALSE:
2238         case FETCH:
2239         case FINAL:
2240         case FLOAT:
2241         case FOR:
2242         case FORALL:
2243         case FORCE:
2244         case FROM:
2245         case FUNCTION:
2246         case GLOBAL:
2247         case GOTO:
2248         case GROUP:
2249         case HASH:
2250         case HAVING:
2251         case HEAP:
2252         case HOUR:
2253         case IF:
2254         case IMMEDIATE:
2255         case IN:
2256         case INDEX:
2257         case INDICES:
2258         case INDEXTYPE:
2259         case INDICATOR:
2260         case INSERT:
2261         case INSTANTIABLE:
2262         case INTEGER:
2263         case INTERFACE:
2264         case INTERSECT:
2265         case INTERVAL:
2266         case INTO:
2267         case INVALIDATE:
2268         case IS:
2269         case ISOLATION:
2270         case JAVA:
2271         case LEVEL:
2272         case LIKE:
2273         case LIMIT:
2274         case LIMITED:
2275         case LOCK:
2276         case LONG:
2277         case LOOP:
2278         case MAP:
2279         case MAX:
2280         case MEMBER:
2281         case MERGE:
2282         case MIN:
2283         case MINUS:
2284         case MINUTE:
2285         case MLSLABEL:
2286         case MODIFY:
2287         case MOD:
2288         case MODE:
2289         case MONTH:
2290         case NATURAL:
2291         case NATURALN:
2292         case NEW:
2293         case NEXTVAL:
2294         case NO:
2295         case NOCOPY:
2296         case NONEDITIONABLE:
2297         case NOT:
2298         case NOWAIT:
2299         case NULL:
2300         case NULLIF:
2301         case NUMBER:
2302         case BFILE_BASE:
2303         case BLOB_BASE:
2304         case CLOB_BASE:
2305         case DATE_BASE:
2306         case NUMBER_BASE:
2307         case OBJECT:
2308         case OCIROWID:
2309         case OF:
2310         case OID:
2311         case ON:
2312         case OPAQUE:
2313         case OPEN:
2314         case OPERATOR:
2315         case OPTION:
2316         case OR:
2317         case ORDER:
2318         case ORGANIZATION:
2319         case OTHERS:
2320         case OUT:
2321         case OVERRIDING:
2322         case PACKAGE:
2323         case PARTITION:
2324         case PCTFREE:
2325         case PLS_INTEGER:
2326         case POSITIVE:
2327         case POSITIVEN:
2328         case PRAGMA:
2329         case PRESERVE:
2330         case PRIOR:
2331         case PROMPT:
2332         case PRIVATE:
2333         case PROCEDURE:
2334         case PUBLIC:
2335         case RAISE:
2336         case RANGE:
2337         case RAW:
2338         case REAL:
2339         case RECORD:
2340         case REF:
2341         case RELEASE:
2342         case RELIES_ON:
2343         case RENAME:
2344         case RESULT:
2345         case RETURN:
2346         case RETURNING:
2347         case REVERSE:
2348         case ROLLBACK:
2349         case ROW:
2350         case ROWS:
2351         case ROWID:
2352         case ROWNUM:
2353         case ROWTYPE:
2354         case SAVE:
2355         case SAVEPOINT:
2356         case SECOND:
2357         case SELECT:
2358         case SELF:
2359         case SEPARATE:
2360         case SET:
2361         case SHARE:
2362         case SMALLINT:
2363         case SPACE:
2364         case SQL:
2365         case SQLCODE:
2366         case SQLERRM:
2367         case START:
2368         case STATIC:
2369         case STDDEV:
2370         case SUBTYPE:
2371         case SUBSTITUTABLE:
2372         case SUCCESSFUL:
2373         case SUM:
2374         case SYNONYM:
2375         case SYSDATE:
2376         case SYS_REFCURSOR:
2377         case TABLE:
2378         case TEMPORARY:
2379         case THEN:
2380         case TIME:
2381         case TIMESTAMP:
2382         case TIMEZONE_REGION:
2383         case TIMEZONE_ABBR:
2384         case TIMEZONE_MINUTE:
2385         case TIMEZONE_HOUR:
2386         case TO:
2387         case TRANSACTION:
2388         case TRIGGER:
2389         case TRUE:
2390         case TYPE:
2391         case UI:
2392         case UNDER:
2393         case USING:
2394         case WHILE:
2395         case YES:
2396         case SHOW:
2397         case A:
2398         case UPDATE:
2399         case VARCHAR:
2400         case VARCHAR2:
2401         case DOUBLE:
2402         case DEC:
2403         case PRECISION:
2404         case INT:
2405         case NUMERIC:
2406         case SIGNTYPE:
2407         case NCHAR:
2408         case NVARCHAR2:
2409         case STRING:
2410         case UROWID:
2411         case VARRAY:
2412         case VARYING:
2413         case BFILE:
2414         case BLOB:
2415         case CLOB:
2416         case NCLOB:
2417         case YEAR:
2418         case LOCAL:
2419         case WITH:
2420         case ZONE:
2421         case CHARACTER:
2422         case AFTER:
2423         case BEFORE:
2424         case OLD:
2425         case PARENT:
2426         case CC_IF:
2427         case ANALYZE:
2428         case ASSOCIATE:
2429         case AUDIT:
2430         case COMPOUND:
2431         case DATABASE:
2432         case CALL:
2433         case DDL:
2434         case DISASSOCIATE:
2435         case EACH:
2436         case FOLLOWS:
2437         case LOGOFF:
2438         case LOGON:
2439         case NESTED:
2440         case NOAUDIT:
2441         case SCHEMA:
2442         case SERVERERROR:
2443         case SHUTDOWN:
2444         case STARTUP:
2445         case STATEMENT:
2446         case STATISTICS:
2447         case SUSPEND:
2448         case TRUNCATE:
2449         case WRAPPED:
2450         case LIBRARY:
2451         case NAME:
2452         case STRUCT:
2453         case CONTEXT:
2454         case PARAMETERS:
2455         case LENGTH:
2456         case TDO:
2457         case MAXLEN:
2458         case CHARSETID:
2459         case CHARSETFORM:
2460         case ACCEPT:
2461         case ACCESSIBLE:
2462         case COPY:
2463         case DEFINE:
2464         case DISCONNECT:
2465         case HOST:
2466         case PRINT:
2467         case QUIT:
2468         case REMARK:
2469         case UNDEFINE:
2470         case VARIABLE:
2471         case WHENEVER:
2472         case ATTACH:
2473         case CAST:
2474         case TREAT:
2475         case TRIM:
2476         case LEFT:
2477         case RIGHT:
2478         case BOTH:
2479         case EMPTY:
2480         case MULTISET:
2481         case SUBMULTISET:
2482         case LEADING:
2483         case TRAILING:
2484         case CHAR_CS:
2485         case NCHAR_CS:
2486         case DBTIMEZONE:
2487         case SESSIONTIMEZONE:
2488         case AUTHENTICATED:
2489         case LINK:
2490         case SHARED:
2491         case DIRECTORY:
2492         case USER:
2493         case IDENTIFIER:
2494         case QUOTED_LITERAL:
2495         case SQLDATA_CLASS:
2496         case CUSTOMDATUM_CLASS:
2497         case ORADATA_CLASS:
2498         case JAVA_INTERFACE_CLASS:
2499           ;
2500           break;
2501         default:
2502           jj_la1[33] = jj_gen;
2503           break label_7;
2504         }
2505         DeclarativeUnit();
2506       }
2507         jjtree.closeNodeScope(jjtn000, true);
2508         jjtc000 = false;
2509         {if (true) return jjtn000 ;}
2510     } catch (Throwable jjte000) {
2511           if (jjtc000) {
2512             jjtree.clearNodeScope(jjtn000);
2513             jjtc000 = false;
2514           } else {
2515             jjtree.popNode();
2516           }
2517           if (jjte000 instanceof RuntimeException) {
2518             {if (true) throw (RuntimeException)jjte000;}
2519           }
2520           if (jjte000 instanceof ParseException) {
2521             {if (true) throw (ParseException)jjte000;}
2522           }
2523           {if (true) throw (Error)jjte000;}
2524     } finally {
2525           if (jjtc000) {
2526             jjtree.closeNodeScope(jjtn000, true);
2527           }
2528     }
2529     throw new Error("Missing return statement in function");
2530   }
2531 
2532   final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533  /*@bgen(jjtree) CompilationDeclarationFragment */
2534   ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535   boolean jjtc000 = true;
2536   jjtree.openNodeScope(jjtn000);
2537     try {
2538       jj_consume_token(CC_IF);
2539       ConditionalOrExpression();
2540       jj_consume_token(CC_THEN);
2541       label_8:
2542       while (true) {
2543         switch (jj_nt.kind) {
2544         case REPLACE:
2545         case DEFINER:
2546         case CURRENT_USER:
2547         case SERIALLY_REUSABLE:
2548         case RESTRICT_REFERENCES:
2549         case EXCEPTION_INIT:
2550         case AUTONOMOUS_TRANSACTION:
2551         case LANGUAGE:
2552         case INLINE:
2553         case ADD:
2554         case AGGREGATE:
2555         case ALL:
2556         case ALTER:
2557         case AND:
2558         case ANY:
2559         case ARRAY:
2560         case AS:
2561         case ASC:
2562         case AT:
2563         case ATTRIBUTE:
2564         case AUTHID:
2565         case AVG:
2566         case BETWEEN:
2567         case BINARY_INTEGER:
2568         case BODY:
2569         case BOOLEAN:
2570         case BULK:
2571         case BY:
2572         case BYTE:
2573         case CASCADE:
2574         case CASE:
2575         case CHAR:
2576         case CHAR_BASE:
2577         case CHECK:
2578         case CLOSE:
2579         case CLUSTER:
2580         case COALESCE:
2581         case COLLECT:
2582         case COLUMN:
2583         case COMMENT:
2584         case COMMIT:
2585         case COMPRESS:
2586         case CONNECT:
2587         case CONSTANT:
2588         case CONSTRUCTOR:
2589         case CONTINUE:
2590         case CONVERT:
2591         case CREATE:
2592         case CURRENT:
2593         case CURRVAL:
2594         case CURSOR:
2595         case DATA:
2596         case DATE:
2597         case DAY:
2598         case DECLARE:
2599         case DECIMAL:
2600         case _DEFAULT:
2601         case DELETE:
2602         case DESC:
2603         case DISABLE:
2604         case DISTINCT:
2605         case DO:
2606         case DROP:
2607         case EDITIONABLE:
2608         case ELEMENT:
2609         case ELSE:
2610         case ELSIF:
2611         case ENABLE:
2612         case ESCAPE:
2613         case EXCEPT:
2614         case EXCEPTION:
2615         case EXCEPTIONS:
2616         case EXCLUSIVE:
2617         case EXECUTE:
2618         case EXISTS:
2619         case EXIT:
2620         case EXTERNAL:
2621         case EXTENDS:
2622         case EXTRACT:
2623         case FALSE:
2624         case FETCH:
2625         case FINAL:
2626         case FLOAT:
2627         case FOR:
2628         case FORALL:
2629         case FORCE:
2630         case FROM:
2631         case FUNCTION:
2632         case GLOBAL:
2633         case GOTO:
2634         case GROUP:
2635         case HASH:
2636         case HAVING:
2637         case HEAP:
2638         case HOUR:
2639         case IF:
2640         case IMMEDIATE:
2641         case IN:
2642         case INDEX:
2643         case INDICES:
2644         case INDEXTYPE:
2645         case INDICATOR:
2646         case INSERT:
2647         case INSTANTIABLE:
2648         case INTEGER:
2649         case INTERFACE:
2650         case INTERSECT:
2651         case INTERVAL:
2652         case INTO:
2653         case INVALIDATE:
2654         case IS:
2655         case ISOLATION:
2656         case JAVA:
2657         case LEVEL:
2658         case LIKE:
2659         case LIMIT:
2660         case LIMITED:
2661         case LOCK:
2662         case LONG:
2663         case LOOP:
2664         case MAP:
2665         case MAX:
2666         case MEMBER:
2667         case MERGE:
2668         case MIN:
2669         case MINUS:
2670         case MINUTE:
2671         case MLSLABEL:
2672         case MODIFY:
2673         case MOD:
2674         case MODE:
2675         case MONTH:
2676         case NATURAL:
2677         case NATURALN:
2678         case NEW:
2679         case NEXTVAL:
2680         case NO:
2681         case NOCOPY:
2682         case NONEDITIONABLE:
2683         case NOT:
2684         case NOWAIT:
2685         case NULL:
2686         case NULLIF:
2687         case NUMBER:
2688         case BFILE_BASE:
2689         case BLOB_BASE:
2690         case CLOB_BASE:
2691         case DATE_BASE:
2692         case NUMBER_BASE:
2693         case OBJECT:
2694         case OCIROWID:
2695         case OF:
2696         case OID:
2697         case ON:
2698         case OPAQUE:
2699         case OPEN:
2700         case OPERATOR:
2701         case OPTION:
2702         case OR:
2703         case ORDER:
2704         case ORGANIZATION:
2705         case OTHERS:
2706         case OUT:
2707         case OVERRIDING:
2708         case PACKAGE:
2709         case PARTITION:
2710         case PCTFREE:
2711         case PLS_INTEGER:
2712         case POSITIVE:
2713         case POSITIVEN:
2714         case PRAGMA:
2715         case PRESERVE:
2716         case PRIOR:
2717         case PROMPT:
2718         case PRIVATE:
2719         case PROCEDURE:
2720         case PUBLIC:
2721         case RAISE:
2722         case RANGE:
2723         case RAW:
2724         case REAL:
2725         case RECORD:
2726         case REF:
2727         case RELEASE:
2728         case RELIES_ON:
2729         case RENAME:
2730         case RESULT:
2731         case RETURN:
2732         case RETURNING:
2733         case REVERSE:
2734         case ROLLBACK:
2735         case ROW:
2736         case ROWS:
2737         case ROWID:
2738         case ROWNUM:
2739         case ROWTYPE:
2740         case SAVE:
2741         case SAVEPOINT:
2742         case SECOND:
2743         case SELECT:
2744         case SELF:
2745         case SEPARATE:
2746         case SET:
2747         case SHARE:
2748         case SMALLINT:
2749         case SPACE:
2750         case SQL:
2751         case SQLCODE:
2752         case SQLERRM:
2753         case START:
2754         case STATIC:
2755         case STDDEV:
2756         case SUBTYPE:
2757         case SUBSTITUTABLE:
2758         case SUCCESSFUL:
2759         case SUM:
2760         case SYNONYM:
2761         case SYSDATE:
2762         case SYS_REFCURSOR:
2763         case TABLE:
2764         case TEMPORARY:
2765         case THEN:
2766         case TIME:
2767         case TIMESTAMP:
2768         case TIMEZONE_REGION:
2769         case TIMEZONE_ABBR:
2770         case TIMEZONE_MINUTE:
2771         case TIMEZONE_HOUR:
2772         case TO:
2773         case TRANSACTION:
2774         case TRIGGER:
2775         case TRUE:
2776         case TYPE:
2777         case UI:
2778         case UNDER:
2779         case USING:
2780         case WHILE:
2781         case YES:
2782         case SHOW:
2783         case A:
2784         case UPDATE:
2785         case VARCHAR:
2786         case VARCHAR2:
2787         case DOUBLE:
2788         case DEC:
2789         case PRECISION:
2790         case INT:
2791         case NUMERIC:
2792         case SIGNTYPE:
2793         case NCHAR:
2794         case NVARCHAR2:
2795         case STRING:
2796         case UROWID:
2797         case VARRAY:
2798         case VARYING:
2799         case BFILE:
2800         case BLOB:
2801         case CLOB:
2802         case NCLOB:
2803         case YEAR:
2804         case LOCAL:
2805         case WITH:
2806         case ZONE:
2807         case CHARACTER:
2808         case AFTER:
2809         case BEFORE:
2810         case OLD:
2811         case PARENT:
2812         case CC_IF:
2813         case CC_ERROR:
2814         case ANALYZE:
2815         case ASSOCIATE:
2816         case AUDIT:
2817         case COMPOUND:
2818         case DATABASE:
2819         case CALL:
2820         case DDL:
2821         case DISASSOCIATE:
2822         case EACH:
2823         case FOLLOWS:
2824         case LOGOFF:
2825         case LOGON:
2826         case NESTED:
2827         case NOAUDIT:
2828         case SCHEMA:
2829         case SERVERERROR:
2830         case SHUTDOWN:
2831         case STARTUP:
2832         case STATEMENT:
2833         case STATISTICS:
2834         case SUSPEND:
2835         case TRUNCATE:
2836         case WRAPPED:
2837         case LIBRARY:
2838         case NAME:
2839         case STRUCT:
2840         case CONTEXT:
2841         case PARAMETERS:
2842         case LENGTH:
2843         case TDO:
2844         case MAXLEN:
2845         case CHARSETID:
2846         case CHARSETFORM:
2847         case ACCEPT:
2848         case ACCESSIBLE:
2849         case COPY:
2850         case DEFINE:
2851         case DISCONNECT:
2852         case HOST:
2853         case PRINT:
2854         case QUIT:
2855         case REMARK:
2856         case UNDEFINE:
2857         case VARIABLE:
2858         case WHENEVER:
2859         case ATTACH:
2860         case CAST:
2861         case TREAT:
2862         case TRIM:
2863         case LEFT:
2864         case RIGHT:
2865         case BOTH:
2866         case EMPTY:
2867         case MULTISET:
2868         case SUBMULTISET:
2869         case LEADING:
2870         case TRAILING:
2871         case CHAR_CS:
2872         case NCHAR_CS:
2873         case DBTIMEZONE:
2874         case SESSIONTIMEZONE:
2875         case AUTHENTICATED:
2876         case LINK:
2877         case SHARED:
2878         case DIRECTORY:
2879         case USER:
2880         case IDENTIFIER:
2881         case QUOTED_LITERAL:
2882         case SQLDATA_CLASS:
2883         case CUSTOMDATUM_CLASS:
2884         case ORADATA_CLASS:
2885         case JAVA_INTERFACE_CLASS:
2886           ;
2887           break;
2888         default:
2889           jj_la1[34] = jj_gen;
2890           break label_8;
2891         }
2892         switch (jj_nt.kind) {
2893         case REPLACE:
2894         case DEFINER:
2895         case CURRENT_USER:
2896         case SERIALLY_REUSABLE:
2897         case RESTRICT_REFERENCES:
2898         case EXCEPTION_INIT:
2899         case AUTONOMOUS_TRANSACTION:
2900         case LANGUAGE:
2901         case INLINE:
2902         case ADD:
2903         case AGGREGATE:
2904         case ALL:
2905         case ALTER:
2906         case AND:
2907         case ANY:
2908         case ARRAY:
2909         case AS:
2910         case ASC:
2911         case AT:
2912         case ATTRIBUTE:
2913         case AUTHID:
2914         case AVG:
2915         case BETWEEN:
2916         case BINARY_INTEGER:
2917         case BODY:
2918         case BOOLEAN:
2919         case BULK:
2920         case BY:
2921         case BYTE:
2922         case CASCADE:
2923         case CASE:
2924         case CHAR:
2925         case CHAR_BASE:
2926         case CHECK:
2927         case CLOSE:
2928         case CLUSTER:
2929         case COALESCE:
2930         case COLLECT:
2931         case COLUMN:
2932         case COMMENT:
2933         case COMMIT:
2934         case COMPRESS:
2935         case CONNECT:
2936         case CONSTANT:
2937         case CONSTRUCTOR:
2938         case CONTINUE:
2939         case CONVERT:
2940         case CREATE:
2941         case CURRENT:
2942         case CURRVAL:
2943         case CURSOR:
2944         case DATA:
2945         case DATE:
2946         case DAY:
2947         case DECLARE:
2948         case DECIMAL:
2949         case _DEFAULT:
2950         case DELETE:
2951         case DESC:
2952         case DISABLE:
2953         case DISTINCT:
2954         case DO:
2955         case DROP:
2956         case EDITIONABLE:
2957         case ELEMENT:
2958         case ELSE:
2959         case ELSIF:
2960         case ENABLE:
2961         case ESCAPE:
2962         case EXCEPT:
2963         case EXCEPTION:
2964         case EXCEPTIONS:
2965         case EXCLUSIVE:
2966         case EXECUTE:
2967         case EXISTS:
2968         case EXIT:
2969         case EXTERNAL:
2970         case EXTENDS:
2971         case EXTRACT:
2972         case FALSE:
2973         case FETCH:
2974         case FINAL:
2975         case FLOAT:
2976         case FOR:
2977         case FORALL:
2978         case FORCE:
2979         case FROM:
2980         case FUNCTION:
2981         case GLOBAL:
2982         case GOTO:
2983         case GROUP:
2984         case HASH:
2985         case HAVING:
2986         case HEAP:
2987         case HOUR:
2988         case IF:
2989         case IMMEDIATE:
2990         case IN:
2991         case INDEX:
2992         case INDICES:
2993         case INDEXTYPE:
2994         case INDICATOR:
2995         case INSERT:
2996         case INSTANTIABLE:
2997         case INTEGER:
2998         case INTERFACE:
2999         case INTERSECT:
3000         case INTERVAL:
3001         case INTO:
3002         case INVALIDATE:
3003         case IS:
3004         case ISOLATION:
3005         case JAVA:
3006         case LEVEL:
3007         case LIKE:
3008         case LIMIT:
3009         case LIMITED:
3010         case LOCK:
3011         case LONG:
3012         case LOOP:
3013         case MAP:
3014         case MAX:
3015         case MEMBER:
3016         case MERGE:
3017         case MIN:
3018         case MINUS:
3019         case MINUTE:
3020         case MLSLABEL:
3021         case MODIFY:
3022         case MOD:
3023         case MODE:
3024         case MONTH:
3025         case NATURAL:
3026         case NATURALN:
3027         case NEW:
3028         case NEXTVAL:
3029         case NO:
3030         case NOCOPY:
3031         case NONEDITIONABLE:
3032         case NOT:
3033         case NOWAIT:
3034         case NULL:
3035         case NULLIF:
3036         case NUMBER:
3037         case BFILE_BASE:
3038         case BLOB_BASE:
3039         case CLOB_BASE:
3040         case DATE_BASE:
3041         case NUMBER_BASE:
3042         case OBJECT:
3043         case OCIROWID:
3044         case OF:
3045         case OID:
3046         case ON:
3047         case OPAQUE:
3048         case OPEN:
3049         case OPERATOR:
3050         case OPTION:
3051         case OR:
3052         case ORDER:
3053         case ORGANIZATION:
3054         case OTHERS:
3055         case OUT:
3056         case OVERRIDING:
3057         case PACKAGE:
3058         case PARTITION:
3059         case PCTFREE:
3060         case PLS_INTEGER:
3061         case POSITIVE:
3062         case POSITIVEN:
3063         case PRAGMA:
3064         case PRESERVE:
3065         case PRIOR:
3066         case PROMPT:
3067         case PRIVATE:
3068         case PROCEDURE:
3069         case PUBLIC:
3070         case RAISE:
3071         case RANGE:
3072         case RAW:
3073         case REAL:
3074         case RECORD:
3075         case REF:
3076         case RELEASE:
3077         case RELIES_ON:
3078         case RENAME:
3079         case RESULT:
3080         case RETURN:
3081         case RETURNING:
3082         case REVERSE:
3083         case ROLLBACK:
3084         case ROW:
3085         case ROWS:
3086         case ROWID:
3087         case ROWNUM:
3088         case ROWTYPE:
3089         case SAVE:
3090         case SAVEPOINT:
3091         case SECOND:
3092         case SELECT:
3093         case SELF:
3094         case SEPARATE:
3095         case SET:
3096         case SHARE:
3097         case SMALLINT:
3098         case SPACE:
3099         case SQL:
3100         case SQLCODE:
3101         case SQLERRM:
3102         case START:
3103         case STATIC:
3104         case STDDEV:
3105         case SUBTYPE:
3106         case SUBSTITUTABLE:
3107         case SUCCESSFUL:
3108         case SUM:
3109         case SYNONYM:
3110         case SYSDATE:
3111         case SYS_REFCURSOR:
3112         case TABLE:
3113         case TEMPORARY:
3114         case THEN:
3115         case TIME:
3116         case TIMESTAMP:
3117         case TIMEZONE_REGION:
3118         case TIMEZONE_ABBR:
3119         case TIMEZONE_MINUTE:
3120         case TIMEZONE_HOUR:
3121         case TO:
3122         case TRANSACTION:
3123         case TRIGGER:
3124         case TRUE:
3125         case TYPE:
3126         case UI:
3127         case UNDER:
3128         case USING:
3129         case WHILE:
3130         case YES:
3131         case SHOW:
3132         case A:
3133         case UPDATE:
3134         case VARCHAR:
3135         case VARCHAR2:
3136         case DOUBLE:
3137         case DEC:
3138         case PRECISION:
3139         case INT:
3140         case NUMERIC:
3141         case SIGNTYPE:
3142         case NCHAR:
3143         case NVARCHAR2:
3144         case STRING:
3145         case UROWID:
3146         case VARRAY:
3147         case VARYING:
3148         case BFILE:
3149         case BLOB:
3150         case CLOB:
3151         case NCLOB:
3152         case YEAR:
3153         case LOCAL:
3154         case WITH:
3155         case ZONE:
3156         case CHARACTER:
3157         case AFTER:
3158         case BEFORE:
3159         case OLD:
3160         case PARENT:
3161         case CC_IF:
3162         case ANALYZE:
3163         case ASSOCIATE:
3164         case AUDIT:
3165         case COMPOUND:
3166         case DATABASE:
3167         case CALL:
3168         case DDL:
3169         case DISASSOCIATE:
3170         case EACH:
3171         case FOLLOWS:
3172         case LOGOFF:
3173         case LOGON:
3174         case NESTED:
3175         case NOAUDIT:
3176         case SCHEMA:
3177         case SERVERERROR:
3178         case SHUTDOWN:
3179         case STARTUP:
3180         case STATEMENT:
3181         case STATISTICS:
3182         case SUSPEND:
3183         case TRUNCATE:
3184         case WRAPPED:
3185         case LIBRARY:
3186         case NAME:
3187         case STRUCT:
3188         case CONTEXT:
3189         case PARAMETERS:
3190         case LENGTH:
3191         case TDO:
3192         case MAXLEN:
3193         case CHARSETID:
3194         case CHARSETFORM:
3195         case ACCEPT:
3196         case ACCESSIBLE:
3197         case COPY:
3198         case DEFINE:
3199         case DISCONNECT:
3200         case HOST:
3201         case PRINT:
3202         case QUIT:
3203         case REMARK:
3204         case UNDEFINE:
3205         case VARIABLE:
3206         case WHENEVER:
3207         case ATTACH:
3208         case CAST:
3209         case TREAT:
3210         case TRIM:
3211         case LEFT:
3212         case RIGHT:
3213         case BOTH:
3214         case EMPTY:
3215         case MULTISET:
3216         case SUBMULTISET:
3217         case LEADING:
3218         case TRAILING:
3219         case CHAR_CS:
3220         case NCHAR_CS:
3221         case DBTIMEZONE:
3222         case SESSIONTIMEZONE:
3223         case AUTHENTICATED:
3224         case LINK:
3225         case SHARED:
3226         case DIRECTORY:
3227         case USER:
3228         case IDENTIFIER:
3229         case QUOTED_LITERAL:
3230         case SQLDATA_CLASS:
3231         case CUSTOMDATUM_CLASS:
3232         case ORADATA_CLASS:
3233         case JAVA_INTERFACE_CLASS:
3234           DeclarativeUnit();
3235           break;
3236         case CC_ERROR:
3237           jj_consume_token(CC_ERROR);
3238           Expression();
3239           jj_consume_token(CC_END);
3240           break;
3241         default:
3242           jj_la1[35] = jj_gen;
3243           jj_consume_token(-1);
3244           throw new ParseException();
3245         }
3246       }
3247       label_9:
3248       while (true) {
3249         switch (jj_nt.kind) {
3250         case CC_ELSIF:
3251           ;
3252           break;
3253         default:
3254           jj_la1[36] = jj_gen;
3255           break label_9;
3256         }
3257         jj_consume_token(CC_ELSIF);
3258         ConditionalOrExpression();
3259         jj_consume_token(CC_THEN);
3260         label_10:
3261         while (true) {
3262           switch (jj_nt.kind) {
3263           case REPLACE:
3264           case DEFINER:
3265           case CURRENT_USER:
3266           case SERIALLY_REUSABLE:
3267           case RESTRICT_REFERENCES:
3268           case EXCEPTION_INIT:
3269           case AUTONOMOUS_TRANSACTION:
3270           case LANGUAGE:
3271           case INLINE:
3272           case ADD:
3273           case AGGREGATE:
3274           case ALL:
3275           case ALTER:
3276           case AND:
3277           case ANY:
3278           case ARRAY:
3279           case AS:
3280           case ASC:
3281           case AT:
3282           case ATTRIBUTE:
3283           case AUTHID:
3284           case AVG:
3285           case BETWEEN:
3286           case BINARY_INTEGER:
3287           case BODY:
3288           case BOOLEAN:
3289           case BULK:
3290           case BY:
3291           case BYTE:
3292           case CASCADE:
3293           case CASE:
3294           case CHAR:
3295           case CHAR_BASE:
3296           case CHECK:
3297           case CLOSE:
3298           case CLUSTER:
3299           case COALESCE:
3300           case COLLECT:
3301           case COLUMN:
3302           case COMMENT:
3303           case COMMIT:
3304           case COMPRESS:
3305           case CONNECT:
3306           case CONSTANT:
3307           case CONSTRUCTOR:
3308           case CONTINUE:
3309           case CONVERT:
3310           case CREATE:
3311           case CURRENT:
3312           case CURRVAL:
3313           case CURSOR:
3314           case DATA:
3315           case DATE:
3316           case DAY:
3317           case DECLARE:
3318           case DECIMAL:
3319           case _DEFAULT:
3320           case DELETE:
3321           case DESC:
3322           case DISABLE:
3323           case DISTINCT:
3324           case DO:
3325           case DROP:
3326           case EDITIONABLE:
3327           case ELEMENT:
3328           case ELSE:
3329           case ELSIF:
3330           case ENABLE:
3331           case ESCAPE:
3332           case EXCEPT:
3333           case EXCEPTION:
3334           case EXCEPTIONS:
3335           case EXCLUSIVE:
3336           case EXECUTE:
3337           case EXISTS:
3338           case EXIT:
3339           case EXTERNAL:
3340           case EXTENDS:
3341           case EXTRACT:
3342           case FALSE:
3343           case FETCH:
3344           case FINAL:
3345           case FLOAT:
3346           case FOR:
3347           case FORALL:
3348           case FORCE:
3349           case FROM:
3350           case FUNCTION:
3351           case GLOBAL:
3352           case GOTO:
3353           case GROUP:
3354           case HASH:
3355           case HAVING:
3356           case HEAP:
3357           case HOUR:
3358           case IF:
3359           case IMMEDIATE:
3360           case IN:
3361           case INDEX:
3362           case INDICES:
3363           case INDEXTYPE:
3364           case INDICATOR:
3365           case INSERT:
3366           case INSTANTIABLE:
3367           case INTEGER:
3368           case INTERFACE:
3369           case INTERSECT:
3370           case INTERVAL:
3371           case INTO:
3372           case INVALIDATE:
3373           case IS:
3374           case ISOLATION:
3375           case JAVA:
3376           case LEVEL:
3377           case LIKE:
3378           case LIMIT:
3379           case LIMITED:
3380           case LOCK:
3381           case LONG:
3382           case LOOP:
3383           case MAP:
3384           case MAX:
3385           case MEMBER:
3386           case MERGE:
3387           case MIN:
3388           case MINUS:
3389           case MINUTE:
3390           case MLSLABEL:
3391           case MODIFY:
3392           case MOD:
3393           case MODE:
3394           case MONTH:
3395           case NATURAL:
3396           case NATURALN:
3397           case NEW:
3398           case NEXTVAL:
3399           case NO:
3400           case NOCOPY:
3401           case NONEDITIONABLE:
3402           case NOT:
3403           case NOWAIT:
3404           case NULL:
3405           case NULLIF:
3406           case NUMBER:
3407           case BFILE_BASE:
3408           case BLOB_BASE:
3409           case CLOB_BASE:
3410           case DATE_BASE:
3411           case NUMBER_BASE:
3412           case OBJECT:
3413           case OCIROWID:
3414           case OF:
3415           case OID:
3416           case ON:
3417           case OPAQUE:
3418           case OPEN:
3419           case OPERATOR:
3420           case OPTION:
3421           case OR:
3422           case ORDER:
3423           case ORGANIZATION:
3424           case OTHERS:
3425           case OUT:
3426           case OVERRIDING:
3427           case PACKAGE:
3428           case PARTITION:
3429           case PCTFREE:
3430           case PLS_INTEGER:
3431           case POSITIVE:
3432           case POSITIVEN:
3433           case PRAGMA:
3434           case PRESERVE:
3435           case PRIOR:
3436           case PROMPT:
3437           case PRIVATE:
3438           case PROCEDURE:
3439           case PUBLIC:
3440           case RAISE:
3441           case RANGE:
3442           case RAW:
3443           case REAL:
3444           case RECORD:
3445           case REF:
3446           case RELEASE:
3447           case RELIES_ON:
3448           case RENAME:
3449           case RESULT:
3450           case RETURN:
3451           case RETURNING:
3452           case REVERSE:
3453           case ROLLBACK:
3454           case ROW:
3455           case ROWS:
3456           case ROWID:
3457           case ROWNUM:
3458           case ROWTYPE:
3459           case SAVE:
3460           case SAVEPOINT:
3461           case SECOND:
3462           case SELECT:
3463           case SELF:
3464           case SEPARATE:
3465           case SET:
3466           case SHARE:
3467           case SMALLINT:
3468           case SPACE:
3469           case SQL:
3470           case SQLCODE:
3471           case SQLERRM:
3472           case START:
3473           case STATIC:
3474           case STDDEV:
3475           case SUBTYPE:
3476           case SUBSTITUTABLE:
3477           case SUCCESSFUL:
3478           case SUM:
3479           case SYNONYM:
3480           case SYSDATE:
3481           case SYS_REFCURSOR:
3482           case TABLE:
3483           case TEMPORARY:
3484           case THEN:
3485           case TIME:
3486           case TIMESTAMP:
3487           case TIMEZONE_REGION:
3488           case TIMEZONE_ABBR:
3489           case TIMEZONE_MINUTE:
3490           case TIMEZONE_HOUR:
3491           case TO:
3492           case TRANSACTION:
3493           case TRIGGER:
3494           case TRUE:
3495           case TYPE:
3496           case UI:
3497           case UNDER:
3498           case USING:
3499           case WHILE:
3500           case YES:
3501           case SHOW:
3502           case A:
3503           case UPDATE:
3504           case VARCHAR:
3505           case VARCHAR2:
3506           case DOUBLE:
3507           case DEC:
3508           case PRECISION:
3509           case INT:
3510           case NUMERIC:
3511           case SIGNTYPE:
3512           case NCHAR:
3513           case NVARCHAR2:
3514           case STRING:
3515           case UROWID:
3516           case VARRAY:
3517           case VARYING:
3518           case BFILE:
3519           case BLOB:
3520           case CLOB:
3521           case NCLOB:
3522           case YEAR:
3523           case LOCAL:
3524           case WITH:
3525           case ZONE:
3526           case CHARACTER:
3527           case AFTER:
3528           case BEFORE:
3529           case OLD:
3530           case PARENT:
3531           case CC_IF:
3532           case CC_ERROR:
3533           case ANALYZE:
3534           case ASSOCIATE:
3535           case AUDIT:
3536           case COMPOUND:
3537           case DATABASE:
3538           case CALL:
3539           case DDL:
3540           case DISASSOCIATE:
3541           case EACH:
3542           case FOLLOWS:
3543           case LOGOFF:
3544           case LOGON:
3545           case NESTED:
3546           case NOAUDIT:
3547           case SCHEMA:
3548           case SERVERERROR:
3549           case SHUTDOWN:
3550           case STARTUP:
3551           case STATEMENT:
3552           case STATISTICS:
3553           case SUSPEND:
3554           case TRUNCATE:
3555           case WRAPPED:
3556           case LIBRARY:
3557           case NAME:
3558           case STRUCT:
3559           case CONTEXT:
3560           case PARAMETERS:
3561           case LENGTH:
3562           case TDO:
3563           case MAXLEN:
3564           case CHARSETID:
3565           case CHARSETFORM:
3566           case ACCEPT:
3567           case ACCESSIBLE:
3568           case COPY:
3569           case DEFINE:
3570           case DISCONNECT:
3571           case HOST:
3572           case PRINT:
3573           case QUIT:
3574           case REMARK:
3575           case UNDEFINE:
3576           case VARIABLE:
3577           case WHENEVER:
3578           case ATTACH:
3579           case CAST:
3580           case TREAT:
3581           case TRIM:
3582           case LEFT:
3583           case RIGHT:
3584           case BOTH:
3585           case EMPTY:
3586           case MULTISET:
3587           case SUBMULTISET:
3588           case LEADING:
3589           case TRAILING:
3590           case CHAR_CS:
3591           case NCHAR_CS:
3592           case DBTIMEZONE:
3593           case SESSIONTIMEZONE:
3594           case AUTHENTICATED:
3595           case LINK:
3596           case SHARED:
3597           case DIRECTORY:
3598           case USER:
3599           case IDENTIFIER:
3600           case QUOTED_LITERAL:
3601           case SQLDATA_CLASS:
3602           case CUSTOMDATUM_CLASS:
3603           case ORADATA_CLASS:
3604           case JAVA_INTERFACE_CLASS:
3605             ;
3606             break;
3607           default:
3608             jj_la1[37] = jj_gen;
3609             break label_10;
3610           }
3611           switch (jj_nt.kind) {
3612           case REPLACE:
3613           case DEFINER:
3614           case CURRENT_USER:
3615           case SERIALLY_REUSABLE:
3616           case RESTRICT_REFERENCES:
3617           case EXCEPTION_INIT:
3618           case AUTONOMOUS_TRANSACTION:
3619           case LANGUAGE:
3620           case INLINE:
3621           case ADD:
3622           case AGGREGATE:
3623           case ALL:
3624           case ALTER:
3625           case AND:
3626           case ANY:
3627           case ARRAY:
3628           case AS:
3629           case ASC:
3630           case AT:
3631           case ATTRIBUTE:
3632           case AUTHID:
3633           case AVG:
3634           case BETWEEN:
3635           case BINARY_INTEGER:
3636           case BODY:
3637           case BOOLEAN:
3638           case BULK:
3639           case BY:
3640           case BYTE:
3641           case CASCADE:
3642           case CASE:
3643           case CHAR:
3644           case CHAR_BASE:
3645           case CHECK:
3646           case CLOSE:
3647           case CLUSTER:
3648           case COALESCE:
3649           case COLLECT:
3650           case COLUMN:
3651           case COMMENT:
3652           case COMMIT:
3653           case COMPRESS:
3654           case CONNECT:
3655           case CONSTANT:
3656           case CONSTRUCTOR:
3657           case CONTINUE:
3658           case CONVERT:
3659           case CREATE:
3660           case CURRENT:
3661           case CURRVAL:
3662           case CURSOR:
3663           case DATA:
3664           case DATE:
3665           case DAY:
3666           case DECLARE:
3667           case DECIMAL:
3668           case _DEFAULT:
3669           case DELETE:
3670           case DESC:
3671           case DISABLE:
3672           case DISTINCT:
3673           case DO:
3674           case DROP:
3675           case EDITIONABLE:
3676           case ELEMENT:
3677           case ELSE:
3678           case ELSIF:
3679           case ENABLE:
3680           case ESCAPE:
3681           case EXCEPT:
3682           case EXCEPTION:
3683           case EXCEPTIONS:
3684           case EXCLUSIVE:
3685           case EXECUTE:
3686           case EXISTS:
3687           case EXIT:
3688           case EXTERNAL:
3689           case EXTENDS:
3690           case EXTRACT:
3691           case FALSE:
3692           case FETCH:
3693           case FINAL:
3694           case FLOAT:
3695           case FOR:
3696           case FORALL:
3697           case FORCE:
3698           case FROM:
3699           case FUNCTION:
3700           case GLOBAL:
3701           case GOTO:
3702           case GROUP:
3703           case HASH:
3704           case HAVING:
3705           case HEAP:
3706           case HOUR:
3707           case IF:
3708           case IMMEDIATE:
3709           case IN:
3710           case INDEX:
3711           case INDICES:
3712           case INDEXTYPE:
3713           case INDICATOR:
3714           case INSERT:
3715           case INSTANTIABLE:
3716           case INTEGER:
3717           case INTERFACE:
3718           case INTERSECT:
3719           case INTERVAL:
3720           case INTO:
3721           case INVALIDATE:
3722           case IS:
3723           case ISOLATION:
3724           case JAVA:
3725           case LEVEL:
3726           case LIKE:
3727           case LIMIT:
3728           case LIMITED:
3729           case LOCK:
3730           case LONG:
3731           case LOOP:
3732           case MAP:
3733           case MAX:
3734           case MEMBER:
3735           case MERGE:
3736           case MIN:
3737           case MINUS:
3738           case MINUTE:
3739           case MLSLABEL:
3740           case MODIFY:
3741           case MOD:
3742           case MODE:
3743           case MONTH:
3744           case NATURAL:
3745           case NATURALN:
3746           case NEW:
3747           case NEXTVAL:
3748           case NO:
3749           case NOCOPY:
3750           case NONEDITIONABLE:
3751           case NOT:
3752           case NOWAIT:
3753           case NULL:
3754           case NULLIF:
3755           case NUMBER:
3756           case BFILE_BASE:
3757           case BLOB_BASE:
3758           case CLOB_BASE:
3759           case DATE_BASE:
3760           case NUMBER_BASE:
3761           case OBJECT:
3762           case OCIROWID:
3763           case OF:
3764           case OID:
3765           case ON:
3766           case OPAQUE:
3767           case OPEN:
3768           case OPERATOR:
3769           case OPTION:
3770           case OR:
3771           case ORDER:
3772           case ORGANIZATION:
3773           case OTHERS:
3774           case OUT:
3775           case OVERRIDING:
3776           case PACKAGE:
3777           case PARTITION:
3778           case PCTFREE:
3779           case PLS_INTEGER:
3780           case POSITIVE:
3781           case POSITIVEN:
3782           case PRAGMA:
3783           case PRESERVE:
3784           case PRIOR:
3785           case PROMPT:
3786           case PRIVATE:
3787           case PROCEDURE:
3788           case PUBLIC:
3789           case RAISE:
3790           case RANGE:
3791           case RAW:
3792           case REAL:
3793           case RECORD:
3794           case REF:
3795           case RELEASE:
3796           case RELIES_ON:
3797           case RENAME:
3798           case RESULT:
3799           case RETURN:
3800           case RETURNING:
3801           case REVERSE:
3802           case ROLLBACK:
3803           case ROW:
3804           case ROWS:
3805           case ROWID:
3806           case ROWNUM:
3807           case ROWTYPE:
3808           case SAVE:
3809           case SAVEPOINT:
3810           case SECOND:
3811           case SELECT:
3812           case SELF:
3813           case SEPARATE:
3814           case SET:
3815           case SHARE:
3816           case SMALLINT:
3817           case SPACE:
3818           case SQL:
3819           case SQLCODE:
3820           case SQLERRM:
3821           case START:
3822           case STATIC:
3823           case STDDEV:
3824           case SUBTYPE:
3825           case SUBSTITUTABLE:
3826           case SUCCESSFUL:
3827           case SUM:
3828           case SYNONYM:
3829           case SYSDATE:
3830           case SYS_REFCURSOR:
3831           case TABLE:
3832           case TEMPORARY:
3833           case THEN:
3834           case TIME:
3835           case TIMESTAMP:
3836           case TIMEZONE_REGION:
3837           case TIMEZONE_ABBR:
3838           case TIMEZONE_MINUTE:
3839           case TIMEZONE_HOUR:
3840           case TO:
3841           case TRANSACTION:
3842           case TRIGGER:
3843           case TRUE:
3844           case TYPE:
3845           case UI:
3846           case UNDER:
3847           case USING:
3848           case WHILE:
3849           case YES:
3850           case SHOW:
3851           case A:
3852           case UPDATE:
3853           case VARCHAR:
3854           case VARCHAR2:
3855           case DOUBLE:
3856           case DEC:
3857           case PRECISION:
3858           case INT:
3859           case NUMERIC:
3860           case SIGNTYPE:
3861           case NCHAR:
3862           case NVARCHAR2:
3863           case STRING:
3864           case UROWID:
3865           case VARRAY:
3866           case VARYING:
3867           case BFILE:
3868           case BLOB:
3869           case CLOB:
3870           case NCLOB:
3871           case YEAR:
3872           case LOCAL:
3873           case WITH:
3874           case ZONE:
3875           case CHARACTER:
3876           case AFTER:
3877           case BEFORE:
3878           case OLD:
3879           case PARENT:
3880           case CC_IF:
3881           case ANALYZE:
3882           case ASSOCIATE:
3883           case AUDIT:
3884           case COMPOUND:
3885           case DATABASE:
3886           case CALL:
3887           case DDL:
3888           case DISASSOCIATE:
3889           case EACH:
3890           case FOLLOWS:
3891           case LOGOFF:
3892           case LOGON:
3893           case NESTED:
3894           case NOAUDIT:
3895           case SCHEMA:
3896           case SERVERERROR:
3897           case SHUTDOWN:
3898           case STARTUP:
3899           case STATEMENT:
3900           case STATISTICS:
3901           case SUSPEND:
3902           case TRUNCATE:
3903           case WRAPPED:
3904           case LIBRARY:
3905           case NAME:
3906           case STRUCT:
3907           case CONTEXT:
3908           case PARAMETERS:
3909           case LENGTH:
3910           case TDO:
3911           case MAXLEN:
3912           case CHARSETID:
3913           case CHARSETFORM:
3914           case ACCEPT:
3915           case ACCESSIBLE:
3916           case COPY:
3917           case DEFINE:
3918           case DISCONNECT:
3919           case HOST:
3920           case PRINT:
3921           case QUIT:
3922           case REMARK:
3923           case UNDEFINE:
3924           case VARIABLE:
3925           case WHENEVER:
3926           case ATTACH:
3927           case CAST:
3928           case TREAT:
3929           case TRIM:
3930           case LEFT:
3931           case RIGHT:
3932           case BOTH:
3933           case EMPTY:
3934           case MULTISET:
3935           case SUBMULTISET:
3936           case LEADING:
3937           case TRAILING:
3938           case CHAR_CS:
3939           case NCHAR_CS:
3940           case DBTIMEZONE:
3941           case SESSIONTIMEZONE:
3942           case AUTHENTICATED:
3943           case LINK:
3944           case SHARED:
3945           case DIRECTORY:
3946           case USER:
3947           case IDENTIFIER:
3948           case QUOTED_LITERAL:
3949           case SQLDATA_CLASS:
3950           case CUSTOMDATUM_CLASS:
3951           case ORADATA_CLASS:
3952           case JAVA_INTERFACE_CLASS:
3953             DeclarativeUnit();
3954             break;
3955           case CC_ERROR:
3956             jj_consume_token(CC_ERROR);
3957             Expression();
3958             jj_consume_token(CC_END);
3959             break;
3960           default:
3961             jj_la1[38] = jj_gen;
3962             jj_consume_token(-1);
3963             throw new ParseException();
3964           }
3965         }
3966       }
3967       label_11:
3968       while (true) {
3969         switch (jj_nt.kind) {
3970         case CC_ELSE:
3971           ;
3972           break;
3973         default:
3974           jj_la1[39] = jj_gen;
3975           break label_11;
3976         }
3977         jj_consume_token(CC_ELSE);
3978         label_12:
3979         while (true) {
3980           switch (jj_nt.kind) {
3981           case REPLACE:
3982           case DEFINER:
3983           case CURRENT_USER:
3984           case SERIALLY_REUSABLE:
3985           case RESTRICT_REFERENCES:
3986           case EXCEPTION_INIT:
3987           case AUTONOMOUS_TRANSACTION:
3988           case LANGUAGE:
3989           case INLINE:
3990           case ADD:
3991           case AGGREGATE:
3992           case ALL:
3993           case ALTER:
3994           case AND:
3995           case ANY:
3996           case ARRAY:
3997           case AS:
3998           case ASC:
3999           case AT:
4000           case ATTRIBUTE:
4001           case AUTHID:
4002           case AVG:
4003           case BETWEEN:
4004           case BINARY_INTEGER:
4005           case BODY:
4006           case BOOLEAN:
4007           case BULK:
4008           case BY:
4009           case BYTE:
4010           case CASCADE:
4011           case CASE:
4012           case CHAR:
4013           case CHAR_BASE:
4014           case CHECK:
4015           case CLOSE:
4016           case CLUSTER:
4017           case COALESCE:
4018           case COLLECT:
4019           case COLUMN:
4020           case COMMENT:
4021           case COMMIT:
4022           case COMPRESS:
4023           case CONNECT:
4024           case CONSTANT:
4025           case CONSTRUCTOR:
4026           case CONTINUE:
4027           case CONVERT:
4028           case CREATE:
4029           case CURRENT:
4030           case CURRVAL:
4031           case CURSOR:
4032           case DATA:
4033           case DATE:
4034           case DAY:
4035           case DECLARE:
4036           case DECIMAL:
4037           case _DEFAULT:
4038           case DELETE:
4039           case DESC:
4040           case DISABLE:
4041           case DISTINCT:
4042           case DO:
4043           case DROP:
4044           case EDITIONABLE:
4045           case ELEMENT:
4046           case ELSE:
4047           case ELSIF:
4048           case ENABLE:
4049           case ESCAPE:
4050           case EXCEPT:
4051           case EXCEPTION:
4052           case EXCEPTIONS:
4053           case EXCLUSIVE:
4054           case EXECUTE:
4055           case EXISTS:
4056           case EXIT:
4057           case EXTERNAL:
4058           case EXTENDS:
4059           case EXTRACT:
4060           case FALSE:
4061           case FETCH:
4062           case FINAL:
4063           case FLOAT:
4064           case FOR:
4065           case FORALL:
4066           case FORCE:
4067           case FROM:
4068           case FUNCTION:
4069           case GLOBAL:
4070           case GOTO:
4071           case GROUP:
4072           case HASH:
4073           case HAVING:
4074           case HEAP:
4075           case HOUR:
4076           case IF:
4077           case IMMEDIATE:
4078           case IN:
4079           case INDEX:
4080           case INDICES:
4081           case INDEXTYPE:
4082           case INDICATOR:
4083           case INSERT:
4084           case INSTANTIABLE:
4085           case INTEGER:
4086           case INTERFACE:
4087           case INTERSECT:
4088           case INTERVAL:
4089           case INTO:
4090           case INVALIDATE:
4091           case IS:
4092           case ISOLATION:
4093           case JAVA:
4094           case LEVEL:
4095           case LIKE:
4096           case LIMIT:
4097           case LIMITED:
4098           case LOCK:
4099           case LONG:
4100           case LOOP:
4101           case MAP:
4102           case MAX:
4103           case MEMBER:
4104           case MERGE:
4105           case MIN:
4106           case MINUS:
4107           case MINUTE:
4108           case MLSLABEL:
4109           case MODIFY:
4110           case MOD:
4111           case MODE:
4112           case MONTH:
4113           case NATURAL:
4114           case NATURALN:
4115           case NEW:
4116           case NEXTVAL:
4117           case NO:
4118           case NOCOPY:
4119           case NONEDITIONABLE:
4120           case NOT:
4121           case NOWAIT:
4122           case NULL:
4123           case NULLIF:
4124           case NUMBER:
4125           case BFILE_BASE:
4126           case BLOB_BASE:
4127           case CLOB_BASE:
4128           case DATE_BASE:
4129           case NUMBER_BASE:
4130           case OBJECT:
4131           case OCIROWID:
4132           case OF:
4133           case OID:
4134           case ON:
4135           case OPAQUE:
4136           case OPEN:
4137           case OPERATOR:
4138           case OPTION:
4139           case OR:
4140           case ORDER:
4141           case ORGANIZATION:
4142           case OTHERS:
4143           case OUT:
4144           case OVERRIDING:
4145           case PACKAGE:
4146           case PARTITION:
4147           case PCTFREE:
4148           case PLS_INTEGER:
4149           case POSITIVE:
4150           case POSITIVEN:
4151           case PRAGMA:
4152           case PRESERVE:
4153           case PRIOR:
4154           case PROMPT:
4155           case PRIVATE:
4156           case PROCEDURE:
4157           case PUBLIC:
4158           case RAISE:
4159           case RANGE:
4160           case RAW:
4161           case REAL:
4162           case RECORD:
4163           case REF:
4164           case RELEASE:
4165           case RELIES_ON:
4166           case RENAME:
4167           case RESULT:
4168           case RETURN:
4169           case RETURNING:
4170           case REVERSE:
4171           case ROLLBACK:
4172           case ROW:
4173           case ROWS:
4174           case ROWID:
4175           case ROWNUM:
4176           case ROWTYPE:
4177           case SAVE:
4178           case SAVEPOINT:
4179           case SECOND:
4180           case SELECT:
4181           case SELF:
4182           case SEPARATE:
4183           case SET:
4184           case SHARE:
4185           case SMALLINT:
4186           case SPACE:
4187           case SQL:
4188           case SQLCODE:
4189           case SQLERRM:
4190           case START:
4191           case STATIC:
4192           case STDDEV:
4193           case SUBTYPE:
4194           case SUBSTITUTABLE:
4195           case SUCCESSFUL:
4196           case SUM:
4197           case SYNONYM:
4198           case SYSDATE:
4199           case SYS_REFCURSOR:
4200           case TABLE:
4201           case TEMPORARY:
4202           case THEN:
4203           case TIME:
4204           case TIMESTAMP:
4205           case TIMEZONE_REGION:
4206           case TIMEZONE_ABBR:
4207           case TIMEZONE_MINUTE:
4208           case TIMEZONE_HOUR:
4209           case TO:
4210           case TRANSACTION:
4211           case TRIGGER:
4212           case TRUE:
4213           case TYPE:
4214           case UI:
4215           case UNDER:
4216           case USING:
4217           case WHILE:
4218           case YES:
4219           case SHOW:
4220           case A:
4221           case UPDATE:
4222           case VARCHAR:
4223           case VARCHAR2:
4224           case DOUBLE:
4225           case DEC:
4226           case PRECISION:
4227           case INT:
4228           case NUMERIC:
4229           case SIGNTYPE:
4230           case NCHAR:
4231           case NVARCHAR2:
4232           case STRING:
4233           case UROWID:
4234           case VARRAY:
4235           case VARYING:
4236           case BFILE:
4237           case BLOB:
4238           case CLOB:
4239           case NCLOB:
4240           case YEAR:
4241           case LOCAL:
4242           case WITH:
4243           case ZONE:
4244           case CHARACTER:
4245           case AFTER:
4246           case BEFORE:
4247           case OLD:
4248           case PARENT:
4249           case CC_IF:
4250           case CC_ERROR:
4251           case ANALYZE:
4252           case ASSOCIATE:
4253           case AUDIT:
4254           case COMPOUND:
4255           case DATABASE:
4256           case CALL:
4257           case DDL:
4258           case DISASSOCIATE:
4259           case EACH:
4260           case FOLLOWS:
4261           case LOGOFF:
4262           case LOGON:
4263           case NESTED:
4264           case NOAUDIT:
4265           case SCHEMA:
4266           case SERVERERROR:
4267           case SHUTDOWN:
4268           case STARTUP:
4269           case STATEMENT:
4270           case STATISTICS:
4271           case SUSPEND:
4272           case TRUNCATE:
4273           case WRAPPED:
4274           case LIBRARY:
4275           case NAME:
4276           case STRUCT:
4277           case CONTEXT:
4278           case PARAMETERS:
4279           case LENGTH:
4280           case TDO:
4281           case MAXLEN:
4282           case CHARSETID:
4283           case CHARSETFORM:
4284           case ACCEPT:
4285           case ACCESSIBLE:
4286           case COPY:
4287           case DEFINE:
4288           case DISCONNECT:
4289           case HOST:
4290           case PRINT:
4291           case QUIT:
4292           case REMARK:
4293           case UNDEFINE:
4294           case VARIABLE:
4295           case WHENEVER:
4296           case ATTACH:
4297           case CAST:
4298           case TREAT:
4299           case TRIM:
4300           case LEFT:
4301           case RIGHT:
4302           case BOTH:
4303           case EMPTY:
4304           case MULTISET:
4305           case SUBMULTISET:
4306           case LEADING:
4307           case TRAILING:
4308           case CHAR_CS:
4309           case NCHAR_CS:
4310           case DBTIMEZONE:
4311           case SESSIONTIMEZONE:
4312           case AUTHENTICATED:
4313           case LINK:
4314           case SHARED:
4315           case DIRECTORY:
4316           case USER:
4317           case IDENTIFIER:
4318           case QUOTED_LITERAL:
4319           case SQLDATA_CLASS:
4320           case CUSTOMDATUM_CLASS:
4321           case ORADATA_CLASS:
4322           case JAVA_INTERFACE_CLASS:
4323             ;
4324             break;
4325           default:
4326             jj_la1[40] = jj_gen;
4327             break label_12;
4328           }
4329           switch (jj_nt.kind) {
4330           case REPLACE:
4331           case DEFINER:
4332           case CURRENT_USER:
4333           case SERIALLY_REUSABLE:
4334           case RESTRICT_REFERENCES:
4335           case EXCEPTION_INIT:
4336           case AUTONOMOUS_TRANSACTION:
4337           case LANGUAGE:
4338           case INLINE:
4339           case ADD:
4340           case AGGREGATE:
4341           case ALL:
4342           case ALTER:
4343           case AND:
4344           case ANY:
4345           case ARRAY:
4346           case AS:
4347           case ASC:
4348           case AT:
4349           case ATTRIBUTE:
4350           case AUTHID:
4351           case AVG:
4352           case BETWEEN:
4353           case BINARY_INTEGER:
4354           case BODY:
4355           case BOOLEAN:
4356           case BULK:
4357           case BY:
4358           case BYTE:
4359           case CASCADE:
4360           case CASE:
4361           case CHAR:
4362           case CHAR_BASE:
4363           case CHECK:
4364           case CLOSE:
4365           case CLUSTER:
4366           case COALESCE:
4367           case COLLECT:
4368           case COLUMN:
4369           case COMMENT:
4370           case COMMIT:
4371           case COMPRESS:
4372           case CONNECT:
4373           case CONSTANT:
4374           case CONSTRUCTOR:
4375           case CONTINUE:
4376           case CONVERT:
4377           case CREATE:
4378           case CURRENT:
4379           case CURRVAL:
4380           case CURSOR:
4381           case DATA:
4382           case DATE:
4383           case DAY:
4384           case DECLARE:
4385           case DECIMAL:
4386           case _DEFAULT:
4387           case DELETE:
4388           case DESC:
4389           case DISABLE:
4390           case DISTINCT:
4391           case DO:
4392           case DROP:
4393           case EDITIONABLE:
4394           case ELEMENT:
4395           case ELSE:
4396           case ELSIF:
4397           case ENABLE:
4398           case ESCAPE:
4399           case EXCEPT:
4400           case EXCEPTION:
4401           case EXCEPTIONS:
4402           case EXCLUSIVE:
4403           case EXECUTE:
4404           case EXISTS:
4405           case EXIT:
4406           case EXTERNAL:
4407           case EXTENDS:
4408           case EXTRACT:
4409           case FALSE:
4410           case FETCH:
4411           case FINAL:
4412           case FLOAT:
4413           case FOR:
4414           case FORALL:
4415           case FORCE:
4416           case FROM:
4417           case FUNCTION:
4418           case GLOBAL:
4419           case GOTO:
4420           case GROUP:
4421           case HASH:
4422           case HAVING:
4423           case HEAP:
4424           case HOUR:
4425           case IF:
4426           case IMMEDIATE:
4427           case IN:
4428           case INDEX:
4429           case INDICES:
4430           case INDEXTYPE:
4431           case INDICATOR:
4432           case INSERT:
4433           case INSTANTIABLE:
4434           case INTEGER:
4435           case INTERFACE:
4436           case INTERSECT:
4437           case INTERVAL:
4438           case INTO:
4439           case INVALIDATE:
4440           case IS:
4441           case ISOLATION:
4442           case JAVA:
4443           case LEVEL:
4444           case LIKE:
4445           case LIMIT:
4446           case LIMITED:
4447           case LOCK:
4448           case LONG:
4449           case LOOP:
4450           case MAP:
4451           case MAX:
4452           case MEMBER:
4453           case MERGE:
4454           case MIN:
4455           case MINUS:
4456           case MINUTE:
4457           case MLSLABEL:
4458           case MODIFY:
4459           case MOD:
4460           case MODE:
4461           case MONTH:
4462           case NATURAL:
4463           case NATURALN:
4464           case NEW:
4465           case NEXTVAL:
4466           case NO:
4467           case NOCOPY:
4468           case NONEDITIONABLE:
4469           case NOT:
4470           case NOWAIT:
4471           case NULL:
4472           case NULLIF:
4473           case NUMBER:
4474           case BFILE_BASE:
4475           case BLOB_BASE:
4476           case CLOB_BASE:
4477           case DATE_BASE:
4478           case NUMBER_BASE:
4479           case OBJECT:
4480           case OCIROWID:
4481           case OF:
4482           case OID:
4483           case ON:
4484           case OPAQUE:
4485           case OPEN:
4486           case OPERATOR:
4487           case OPTION:
4488           case OR:
4489           case ORDER:
4490           case ORGANIZATION:
4491           case OTHERS:
4492           case OUT:
4493           case OVERRIDING:
4494           case PACKAGE:
4495           case PARTITION:
4496           case PCTFREE:
4497           case PLS_INTEGER:
4498           case POSITIVE:
4499           case POSITIVEN:
4500           case PRAGMA:
4501           case PRESERVE:
4502           case PRIOR:
4503           case PROMPT:
4504           case PRIVATE:
4505           case PROCEDURE:
4506           case PUBLIC:
4507           case RAISE:
4508           case RANGE:
4509           case RAW:
4510           case REAL:
4511           case RECORD:
4512           case REF:
4513           case RELEASE:
4514           case RELIES_ON:
4515           case RENAME:
4516           case RESULT:
4517           case RETURN:
4518           case RETURNING:
4519           case REVERSE:
4520           case ROLLBACK:
4521           case ROW:
4522           case ROWS:
4523           case ROWID:
4524           case ROWNUM:
4525           case ROWTYPE:
4526           case SAVE:
4527           case SAVEPOINT:
4528           case SECOND:
4529           case SELECT:
4530           case SELF:
4531           case SEPARATE:
4532           case SET:
4533           case SHARE:
4534           case SMALLINT:
4535           case SPACE:
4536           case SQL:
4537           case SQLCODE:
4538           case SQLERRM:
4539           case START:
4540           case STATIC:
4541           case STDDEV:
4542           case SUBTYPE:
4543           case SUBSTITUTABLE:
4544           case SUCCESSFUL:
4545           case SUM:
4546           case SYNONYM:
4547           case SYSDATE:
4548           case SYS_REFCURSOR:
4549           case TABLE:
4550           case TEMPORARY:
4551           case THEN:
4552           case TIME:
4553           case TIMESTAMP:
4554           case TIMEZONE_REGION:
4555           case TIMEZONE_ABBR:
4556           case TIMEZONE_MINUTE:
4557           case TIMEZONE_HOUR:
4558           case TO:
4559           case TRANSACTION:
4560           case TRIGGER:
4561           case TRUE:
4562           case TYPE:
4563           case UI:
4564           case UNDER:
4565           case USING:
4566           case WHILE:
4567           case YES:
4568           case SHOW:
4569           case A:
4570           case UPDATE:
4571           case VARCHAR:
4572           case VARCHAR2:
4573           case DOUBLE:
4574           case DEC:
4575           case PRECISION:
4576           case INT:
4577           case NUMERIC:
4578           case SIGNTYPE:
4579           case NCHAR:
4580           case NVARCHAR2:
4581           case STRING:
4582           case UROWID:
4583           case VARRAY:
4584           case VARYING:
4585           case BFILE:
4586           case BLOB:
4587           case CLOB:
4588           case NCLOB:
4589           case YEAR:
4590           case LOCAL:
4591           case WITH:
4592           case ZONE:
4593           case CHARACTER:
4594           case AFTER:
4595           case BEFORE:
4596           case OLD:
4597           case PARENT:
4598           case CC_IF:
4599           case ANALYZE:
4600           case ASSOCIATE:
4601           case AUDIT:
4602           case COMPOUND:
4603           case DATABASE:
4604           case CALL:
4605           case DDL:
4606           case DISASSOCIATE:
4607           case EACH:
4608           case FOLLOWS:
4609           case LOGOFF:
4610           case LOGON:
4611           case NESTED:
4612           case NOAUDIT:
4613           case SCHEMA:
4614           case SERVERERROR:
4615           case SHUTDOWN:
4616           case STARTUP:
4617           case STATEMENT:
4618           case STATISTICS:
4619           case SUSPEND:
4620           case TRUNCATE:
4621           case WRAPPED:
4622           case LIBRARY:
4623           case NAME:
4624           case STRUCT:
4625           case CONTEXT:
4626           case PARAMETERS:
4627           case LENGTH:
4628           case TDO:
4629           case MAXLEN:
4630           case CHARSETID:
4631           case CHARSETFORM:
4632           case ACCEPT:
4633           case ACCESSIBLE:
4634           case COPY:
4635           case DEFINE:
4636           case DISCONNECT:
4637           case HOST:
4638           case PRINT:
4639           case QUIT:
4640           case REMARK:
4641           case UNDEFINE:
4642           case VARIABLE:
4643           case WHENEVER:
4644           case ATTACH:
4645           case CAST:
4646           case TREAT:
4647           case TRIM:
4648           case LEFT:
4649           case RIGHT:
4650           case BOTH:
4651           case EMPTY:
4652           case MULTISET:
4653           case SUBMULTISET:
4654           case LEADING:
4655           case TRAILING:
4656           case CHAR_CS:
4657           case NCHAR_CS:
4658           case DBTIMEZONE:
4659           case SESSIONTIMEZONE:
4660           case AUTHENTICATED:
4661           case LINK:
4662           case SHARED:
4663           case DIRECTORY:
4664           case USER:
4665           case IDENTIFIER:
4666           case QUOTED_LITERAL:
4667           case SQLDATA_CLASS:
4668           case CUSTOMDATUM_CLASS:
4669           case ORADATA_CLASS:
4670           case JAVA_INTERFACE_CLASS:
4671             DeclarativeUnit();
4672             break;
4673           case CC_ERROR:
4674             jj_consume_token(CC_ERROR);
4675             Expression();
4676             jj_consume_token(CC_END);
4677             break;
4678           default:
4679             jj_la1[41] = jj_gen;
4680             jj_consume_token(-1);
4681             throw new ParseException();
4682           }
4683         }
4684       }
4685       jj_consume_token(CC_END);
4686         jjtree.closeNodeScope(jjtn000, true);
4687         jjtc000 = false;
4688         {if (true) return jjtn000 ;}
4689     } catch (Throwable jjte000) {
4690           if (jjtc000) {
4691             jjtree.clearNodeScope(jjtn000);
4692             jjtc000 = false;
4693           } else {
4694             jjtree.popNode();
4695           }
4696           if (jjte000 instanceof RuntimeException) {
4697             {if (true) throw (RuntimeException)jjte000;}
4698           }
4699           if (jjte000 instanceof ParseException) {
4700             {if (true) throw (ParseException)jjte000;}
4701           }
4702           {if (true) throw (Error)jjte000;}
4703     } finally {
4704           if (jjtc000) {
4705             jjtree.closeNodeScope(jjtn000, true);
4706           }
4707     }
4708     throw new Error("Missing return statement in function");
4709   }
4710 
4711 /**
4712  * 2006-05-22 - Matthias Hendler - Printing of custom tag "@deprecated" removed.
4713  *                                 Printing of any custom tag added. Now user can define his own
4714  *								   custom tags which he can evaluate in the XSLT.
4715  *                                 This methode also documents global functions/procedures.
4716  */
4717   final public ASTProgramUnit ProgramUnit() throws ParseException {
4718  /*@bgen(jjtree) ProgramUnit */
4719   ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720   boolean jjtc000 = true;
4721   jjtree.openNodeScope(jjtn000);
4722     try {
4723       switch (jj_nt.kind) {
4724       case CREATE:
4725         jj_consume_token(CREATE);
4726         switch (jj_nt.kind) {
4727         case OR:
4728           jj_consume_token(OR);
4729           jj_consume_token(REPLACE);
4730           break;
4731         default:
4732           jj_la1[42] = jj_gen;
4733           ;
4734         }
4735         switch (jj_nt.kind) {
4736         case EDITIONABLE:
4737         case NONEDITIONABLE:
4738           switch (jj_nt.kind) {
4739           case EDITIONABLE:
4740             jj_consume_token(EDITIONABLE);
4741             break;
4742           case NONEDITIONABLE:
4743             jj_consume_token(NONEDITIONABLE);
4744             break;
4745           default:
4746             jj_la1[43] = jj_gen;
4747             jj_consume_token(-1);
4748             throw new ParseException();
4749           }
4750           break;
4751         default:
4752           jj_la1[44] = jj_gen;
4753           ;
4754         }
4755         break;
4756       default:
4757         jj_la1[45] = jj_gen;
4758         ;
4759       }
4760       MethodDeclarator();
4761       switch (jj_nt.kind) {
4762       case WRAPPED:
4763         WrappedObject();
4764         break;
4765       case 4:
4766       case AGGREGATE:
4767       case AS:
4768       case AUTHID:
4769       case DETERMINISTIC:
4770       case IS:
4771       case PARALLEL_ENABLE:
4772       case PIPELINED:
4773       case RESULT_CACHE:
4774       case ACCESSIBLE:
4775         label_13:
4776         while (true) {
4777           switch (jj_nt.kind) {
4778           case AUTHID:
4779           case DETERMINISTIC:
4780           case PARALLEL_ENABLE:
4781           case PIPELINED:
4782           case RESULT_CACHE:
4783           case ACCESSIBLE:
4784             ;
4785             break;
4786           default:
4787             jj_la1[46] = jj_gen;
4788             break label_13;
4789           }
4790           switch (jj_nt.kind) {
4791           case AUTHID:
4792             jj_consume_token(AUTHID);
4793             switch (jj_nt.kind) {
4794             case CURRENT_USER:
4795               jj_consume_token(CURRENT_USER);
4796               break;
4797             case DEFINER:
4798               jj_consume_token(DEFINER);
4799               break;
4800             default:
4801               jj_la1[47] = jj_gen;
4802               jj_consume_token(-1);
4803               throw new ParseException();
4804             }
4805             break;
4806           case DETERMINISTIC:
4807             jj_consume_token(DETERMINISTIC);
4808             break;
4809           case ACCESSIBLE:
4810             AccessibleByClause();
4811             break;
4812           case PARALLEL_ENABLE:
4813             jj_consume_token(PARALLEL_ENABLE);
4814             switch (jj_nt.kind) {
4815             case 5:
4816               ParallelClause();
4817               break;
4818             default:
4819               jj_la1[48] = jj_gen;
4820               ;
4821             }
4822             switch (jj_nt.kind) {
4823             case USING:
4824               jj_consume_token(USING);
4825               ID();
4826               switch (jj_nt.kind) {
4827               case 3:
4828                 jj_consume_token(3);
4829                 ID();
4830                 break;
4831               default:
4832                 jj_la1[49] = jj_gen;
4833                 ;
4834               }
4835               break;
4836             default:
4837               jj_la1[50] = jj_gen;
4838               ;
4839             }
4840             break;
4841           case PIPELINED:
4842             jj_consume_token(PIPELINED);
4843             switch (jj_nt.kind) {
4844             case CLUSTER:
4845             case ORDER:
4846             case USING:
4847               switch (jj_nt.kind) {
4848               case USING:
4849                 jj_consume_token(USING);
4850                 ID();
4851                 switch (jj_nt.kind) {
4852                 case 3:
4853                   jj_consume_token(3);
4854                   ID();
4855                   break;
4856                 default:
4857                   jj_la1[51] = jj_gen;
4858                   ;
4859                 }
4860                 break;
4861               case CLUSTER:
4862               case ORDER:
4863                 switch (jj_nt.kind) {
4864                 case ORDER:
4865                   jj_consume_token(ORDER);
4866                   break;
4867                 case CLUSTER:
4868                   jj_consume_token(CLUSTER);
4869                   break;
4870                 default:
4871                   jj_la1[52] = jj_gen;
4872                   jj_consume_token(-1);
4873                   throw new ParseException();
4874                 }
4875                 switch (jj_nt.kind) {
4876                 case REPLACE:
4877                 case DEFINER:
4878                 case CURRENT_USER:
4879                 case SERIALLY_REUSABLE:
4880                 case RESTRICT_REFERENCES:
4881                 case EXCEPTION_INIT:
4882                 case AUTONOMOUS_TRANSACTION:
4883                 case LANGUAGE:
4884                 case INLINE:
4885                 case ADD:
4886                 case AGGREGATE:
4887                 case ALL:
4888                 case ALTER:
4889                 case AND:
4890                 case ANY:
4891                 case ARRAY:
4892                 case AS:
4893                 case ASC:
4894                 case AT:
4895                 case ATTRIBUTE:
4896                 case AUTHID:
4897                 case AVG:
4898                 case BETWEEN:
4899                 case BINARY_INTEGER:
4900                 case BODY:
4901                 case BOOLEAN:
4902                 case BULK:
4903                 case BY:
4904                 case BYTE:
4905                 case CASCADE:
4906                 case CASE:
4907                 case CHAR:
4908                 case CHAR_BASE:
4909                 case CHECK:
4910                 case CLOSE:
4911                 case CLUSTER:
4912                 case COALESCE:
4913                 case COLLECT:
4914                 case COLUMN:
4915                 case COMMENT:
4916                 case COMMIT:
4917                 case COMPRESS:
4918                 case CONNECT:
4919                 case CONSTANT:
4920                 case CONSTRUCTOR:
4921                 case CONTINUE:
4922                 case CONVERT:
4923                 case CREATE:
4924                 case CURRENT:
4925                 case CURRVAL:
4926                 case CURSOR:
4927                 case DATA:
4928                 case DATE:
4929                 case DAY:
4930                 case DECLARE:
4931                 case DECIMAL:
4932                 case _DEFAULT:
4933                 case DELETE:
4934                 case DESC:
4935                 case DISABLE:
4936                 case DISTINCT:
4937                 case DO:
4938                 case DROP:
4939                 case EDITIONABLE:
4940                 case ELEMENT:
4941                 case ELSE:
4942                 case ELSIF:
4943                 case ENABLE:
4944                 case ESCAPE:
4945                 case EXCEPT:
4946                 case EXCEPTION:
4947                 case EXCEPTIONS:
4948                 case EXCLUSIVE:
4949                 case EXECUTE:
4950                 case EXISTS:
4951                 case EXIT:
4952                 case EXTERNAL:
4953                 case EXTENDS:
4954                 case EXTRACT:
4955                 case FALSE:
4956                 case FETCH:
4957                 case FINAL:
4958                 case FLOAT:
4959                 case FOR:
4960                 case FORALL:
4961                 case FORCE:
4962                 case FROM:
4963                 case FUNCTION:
4964                 case GLOBAL:
4965                 case GOTO:
4966                 case GROUP:
4967                 case HASH:
4968                 case HAVING:
4969                 case HEAP:
4970                 case HOUR:
4971                 case IF:
4972                 case IMMEDIATE:
4973                 case IN:
4974                 case INDEX:
4975                 case INDICES:
4976                 case INDEXTYPE:
4977                 case INDICATOR:
4978                 case INSERT:
4979                 case INSTANTIABLE:
4980                 case INTEGER:
4981                 case INTERFACE:
4982                 case INTERSECT:
4983                 case INTERVAL:
4984                 case INTO:
4985                 case INVALIDATE:
4986                 case IS:
4987                 case ISOLATION:
4988                 case JAVA:
4989                 case LEVEL:
4990                 case LIKE:
4991                 case LIMIT:
4992                 case LIMITED:
4993                 case LOCK:
4994                 case LONG:
4995                 case LOOP:
4996                 case MAP:
4997                 case MAX:
4998                 case MEMBER:
4999                 case MERGE:
5000                 case MIN:
5001                 case MINUS:
5002                 case MINUTE:
5003                 case MLSLABEL:
5004                 case MODIFY:
5005                 case MOD:
5006                 case MODE:
5007                 case MONTH:
5008                 case NATURAL:
5009                 case NATURALN:
5010                 case NEW:
5011                 case NEXTVAL:
5012                 case NO:
5013                 case NOCOPY:
5014                 case NONEDITIONABLE:
5015                 case NOT:
5016                 case NOWAIT:
5017                 case NULL:
5018                 case NULLIF:
5019                 case NUMBER:
5020                 case BFILE_BASE:
5021                 case BLOB_BASE:
5022                 case CLOB_BASE:
5023                 case DATE_BASE:
5024                 case NUMBER_BASE:
5025                 case OBJECT:
5026                 case OCIROWID:
5027                 case OF:
5028                 case OID:
5029                 case ON:
5030                 case OPAQUE:
5031                 case OPEN:
5032                 case OPERATOR:
5033                 case OPTION:
5034                 case OR:
5035                 case ORDER:
5036                 case ORGANIZATION:
5037                 case OTHERS:
5038                 case OUT:
5039                 case OVERRIDING:
5040                 case PACKAGE:
5041                 case PARTITION:
5042                 case PCTFREE:
5043                 case PLS_INTEGER:
5044                 case POSITIVE:
5045                 case POSITIVEN:
5046                 case PRESERVE:
5047                 case PRIOR:
5048                 case PROMPT:
5049                 case PRIVATE:
5050                 case PROCEDURE:
5051                 case PUBLIC:
5052                 case RAISE:
5053                 case RANGE:
5054                 case RAW:
5055                 case REAL:
5056                 case RECORD:
5057                 case REF:
5058                 case RELEASE:
5059                 case RELIES_ON:
5060                 case RENAME:
5061                 case RESULT:
5062                 case RETURN:
5063                 case RETURNING:
5064                 case REVERSE:
5065                 case ROLLBACK:
5066                 case ROW:
5067                 case ROWS:
5068                 case ROWID:
5069                 case ROWNUM:
5070                 case ROWTYPE:
5071                 case SAVE:
5072                 case SAVEPOINT:
5073                 case SECOND:
5074                 case SELECT:
5075                 case SELF:
5076                 case SEPARATE:
5077                 case SET:
5078                 case SHARE:
5079                 case SMALLINT:
5080                 case SPACE:
5081                 case SQL:
5082                 case SQLCODE:
5083                 case SQLERRM:
5084                 case START:
5085                 case STATIC:
5086                 case STDDEV:
5087                 case SUBTYPE:
5088                 case SUBSTITUTABLE:
5089                 case SUCCESSFUL:
5090                 case SUM:
5091                 case SYNONYM:
5092                 case SYSDATE:
5093                 case SYS_REFCURSOR:
5094                 case TABLE:
5095                 case TEMPORARY:
5096                 case THEN:
5097                 case TIME:
5098                 case TIMESTAMP:
5099                 case TIMEZONE_REGION:
5100                 case TIMEZONE_ABBR:
5101                 case TIMEZONE_MINUTE:
5102                 case TIMEZONE_HOUR:
5103                 case TO:
5104                 case TRANSACTION:
5105                 case TRIGGER:
5106                 case TRUE:
5107                 case TYPE:
5108                 case UI:
5109                 case UNDER:
5110                 case USING:
5111                 case WHILE:
5112                 case YES:
5113                 case SHOW:
5114                 case A:
5115                 case UPDATE:
5116                 case VARCHAR:
5117                 case VARCHAR2:
5118                 case DOUBLE:
5119                 case DEC:
5120                 case PRECISION:
5121                 case INT:
5122                 case NUMERIC:
5123                 case SIGNTYPE:
5124                 case NCHAR:
5125                 case NVARCHAR2:
5126                 case STRING:
5127                 case UROWID:
5128                 case VARRAY:
5129                 case VARYING:
5130                 case BFILE:
5131                 case BLOB:
5132                 case CLOB:
5133                 case NCLOB:
5134                 case YEAR:
5135                 case LOCAL:
5136                 case WITH:
5137                 case ZONE:
5138                 case CHARACTER:
5139                 case AFTER:
5140                 case BEFORE:
5141                 case OLD:
5142                 case PARENT:
5143                 case ANALYZE:
5144                 case ASSOCIATE:
5145                 case AUDIT:
5146                 case COMPOUND:
5147                 case DATABASE:
5148                 case CALL:
5149                 case DDL:
5150                 case DISASSOCIATE:
5151                 case EACH:
5152                 case FOLLOWS:
5153                 case LOGOFF:
5154                 case LOGON:
5155                 case NESTED:
5156                 case NOAUDIT:
5157                 case SCHEMA:
5158                 case SERVERERROR:
5159                 case SHUTDOWN:
5160                 case STARTUP:
5161                 case STATEMENT:
5162                 case STATISTICS:
5163                 case SUSPEND:
5164                 case TRUNCATE:
5165                 case WRAPPED:
5166                 case LIBRARY:
5167                 case NAME:
5168                 case STRUCT:
5169                 case CONTEXT:
5170                 case PARAMETERS:
5171                 case LENGTH:
5172                 case TDO:
5173                 case MAXLEN:
5174                 case CHARSETID:
5175                 case CHARSETFORM:
5176                 case ACCEPT:
5177                 case ACCESSIBLE:
5178                 case COPY:
5179                 case DEFINE:
5180                 case DISCONNECT:
5181                 case HOST:
5182                 case PRINT:
5183                 case QUIT:
5184                 case REMARK:
5185                 case UNDEFINE:
5186                 case VARIABLE:
5187                 case WHENEVER:
5188                 case ATTACH:
5189                 case CAST:
5190                 case TREAT:
5191                 case TRIM:
5192                 case LEFT:
5193                 case RIGHT:
5194                 case BOTH:
5195                 case EMPTY:
5196                 case MULTISET:
5197                 case SUBMULTISET:
5198                 case LEADING:
5199                 case TRAILING:
5200                 case CHAR_CS:
5201                 case NCHAR_CS:
5202                 case DBTIMEZONE:
5203                 case SESSIONTIMEZONE:
5204                 case AUTHENTICATED:
5205                 case LINK:
5206                 case SHARED:
5207                 case DIRECTORY:
5208                 case USER:
5209                 case IDENTIFIER:
5210                 case QUOTED_LITERAL:
5211                 case SQLDATA_CLASS:
5212                 case CUSTOMDATUM_CLASS:
5213                 case ORADATA_CLASS:
5214                 case JAVA_INTERFACE_CLASS:
5215                   ID();
5216                   break;
5217                 default:
5218                   jj_la1[53] = jj_gen;
5219                   ;
5220                 }
5221                 jj_consume_token(BY);
5222                 jj_consume_token(5);
5223                 ID();
5224                 label_14:
5225                 while (true) {
5226                   switch (jj_nt.kind) {
5227                   case 6:
5228                     ;
5229                     break;
5230                   default:
5231                     jj_la1[54] = jj_gen;
5232                     break label_14;
5233                   }
5234                   jj_consume_token(6);
5235                   ID();
5236                 }
5237                 jj_consume_token(7);
5238                 break;
5239               default:
5240                 jj_la1[55] = jj_gen;
5241                 jj_consume_token(-1);
5242                 throw new ParseException();
5243               }
5244               break;
5245             default:
5246               jj_la1[56] = jj_gen;
5247               ;
5248             }
5249             break;
5250           case RESULT_CACHE:
5251             jj_consume_token(RESULT_CACHE);
5252             switch (jj_nt.kind) {
5253             case RELIES_ON:
5254               jj_consume_token(RELIES_ON);
5255               jj_consume_token(5);
5256               ID();
5257               switch (jj_nt.kind) {
5258               case 3:
5259                 jj_consume_token(3);
5260                 ID();
5261                 break;
5262               default:
5263                 jj_la1[57] = jj_gen;
5264                 ;
5265               }
5266               label_15:
5267               while (true) {
5268                 switch (jj_nt.kind) {
5269                 case 6:
5270                   ;
5271                   break;
5272                 default:
5273                   jj_la1[58] = jj_gen;
5274                   break label_15;
5275                 }
5276                 jj_consume_token(6);
5277                 ID();
5278                 switch (jj_nt.kind) {
5279                 case 3:
5280                   jj_consume_token(3);
5281                   ID();
5282                   break;
5283                 default:
5284                   jj_la1[59] = jj_gen;
5285                   ;
5286                 }
5287               }
5288               jj_consume_token(7);
5289               break;
5290             default:
5291               jj_la1[60] = jj_gen;
5292               ;
5293             }
5294             break;
5295           default:
5296             jj_la1[61] = jj_gen;
5297             jj_consume_token(-1);
5298             throw new ParseException();
5299           }
5300         }
5301         switch (jj_nt.kind) {
5302         case AGGREGATE:
5303           jj_consume_token(AGGREGATE);
5304           jj_consume_token(USING);
5305           ID();
5306           break;
5307         default:
5308           jj_la1[62] = jj_gen;
5309           ;
5310         }
5311         switch (jj_nt.kind) {
5312         case AS:
5313         case IS:
5314           switch (jj_nt.kind) {
5315           case IS:
5316             jj_consume_token(IS);
5317             break;
5318           case AS:
5319             jj_consume_token(AS);
5320             break;
5321           default:
5322             jj_la1[63] = jj_gen;
5323             jj_consume_token(-1);
5324             throw new ParseException();
5325           }
5326           if (jj_2_21(2)) {
5327             CallSpecTail();
5328           } else {
5329             switch (jj_nt.kind) {
5330             case REPLACE:
5331             case DEFINER:
5332             case CURRENT_USER:
5333             case SERIALLY_REUSABLE:
5334             case RESTRICT_REFERENCES:
5335             case EXCEPTION_INIT:
5336             case AUTONOMOUS_TRANSACTION:
5337             case LANGUAGE:
5338             case INLINE:
5339             case ADD:
5340             case AGGREGATE:
5341             case ALL:
5342             case ALTER:
5343             case AND:
5344             case ANY:
5345             case ARRAY:
5346             case AS:
5347             case ASC:
5348             case AT:
5349             case ATTRIBUTE:
5350             case AUTHID:
5351             case AVG:
5352             case BEGIN:
5353             case BETWEEN:
5354             case BINARY_INTEGER:
5355             case BODY:
5356             case BOOLEAN:
5357             case BULK:
5358             case BY:
5359             case BYTE:
5360             case CASCADE:
5361             case CASE:
5362             case CHAR:
5363             case CHAR_BASE:
5364             case CHECK:
5365             case CLOSE:
5366             case CLUSTER:
5367             case COALESCE:
5368             case COLLECT:
5369             case COLUMN:
5370             case COMMENT:
5371             case COMMIT:
5372             case COMPRESS:
5373             case CONNECT:
5374             case CONSTANT:
5375             case CONSTRUCTOR:
5376             case CONTINUE:
5377             case CONVERT:
5378             case CREATE:
5379             case CURRENT:
5380             case CURRVAL:
5381             case CURSOR:
5382             case DATA:
5383             case DATE:
5384             case DAY:
5385             case DECLARE:
5386             case DECIMAL:
5387             case _DEFAULT:
5388             case DELETE:
5389             case DESC:
5390             case DISABLE:
5391             case DISTINCT:
5392             case DO:
5393             case DROP:
5394             case EDITIONABLE:
5395             case ELEMENT:
5396             case ELSE:
5397             case ELSIF:
5398             case ENABLE:
5399             case ESCAPE:
5400             case EXCEPT:
5401             case EXCEPTION:
5402             case EXCEPTIONS:
5403             case EXCLUSIVE:
5404             case EXECUTE:
5405             case EXISTS:
5406             case EXIT:
5407             case EXTERNAL:
5408             case EXTENDS:
5409             case EXTRACT:
5410             case FALSE:
5411             case FETCH:
5412             case FINAL:
5413             case FLOAT:
5414             case FOR:
5415             case FORALL:
5416             case FORCE:
5417             case FROM:
5418             case FUNCTION:
5419             case GLOBAL:
5420             case GOTO:
5421             case GROUP:
5422             case HASH:
5423             case HAVING:
5424             case HEAP:
5425             case HOUR:
5426             case IF:
5427             case IMMEDIATE:
5428             case IN:
5429             case INDEX:
5430             case INDICES:
5431             case INDEXTYPE:
5432             case INDICATOR:
5433             case INSERT:
5434             case INSTANTIABLE:
5435             case INTEGER:
5436             case INTERFACE:
5437             case INTERSECT:
5438             case INTERVAL:
5439             case INTO:
5440             case INVALIDATE:
5441             case IS:
5442             case ISOLATION:
5443             case JAVA:
5444             case LEVEL:
5445             case LIKE:
5446             case LIMIT:
5447             case LIMITED:
5448             case LOCK:
5449             case LONG:
5450             case LOOP:
5451             case MAP:
5452             case MAX:
5453             case MEMBER:
5454             case MERGE:
5455             case MIN:
5456             case MINUS:
5457             case MINUTE:
5458             case MLSLABEL:
5459             case MODIFY:
5460             case MOD:
5461             case MODE:
5462             case MONTH:
5463             case NATURAL:
5464             case NATURALN:
5465             case NEW:
5466             case NEXTVAL:
5467             case NO:
5468             case NOCOPY:
5469             case NONEDITIONABLE:
5470             case NOT:
5471             case NOWAIT:
5472             case NULL:
5473             case NULLIF:
5474             case NUMBER:
5475             case BFILE_BASE:
5476             case BLOB_BASE:
5477             case CLOB_BASE:
5478             case DATE_BASE:
5479             case NUMBER_BASE:
5480             case OBJECT:
5481             case OCIROWID:
5482             case OF:
5483             case OID:
5484             case ON:
5485             case OPAQUE:
5486             case OPEN:
5487             case OPERATOR:
5488             case OPTION:
5489             case OR:
5490             case ORDER:
5491             case ORGANIZATION:
5492             case OTHERS:
5493             case OUT:
5494             case OVERRIDING:
5495             case PACKAGE:
5496             case PARTITION:
5497             case PCTFREE:
5498             case PLS_INTEGER:
5499             case POSITIVE:
5500             case POSITIVEN:
5501             case PRAGMA:
5502             case PRESERVE:
5503             case PRIOR:
5504             case PROMPT:
5505             case PRIVATE:
5506             case PROCEDURE:
5507             case PUBLIC:
5508             case RAISE:
5509             case RANGE:
5510             case RAW:
5511             case REAL:
5512             case RECORD:
5513             case REF:
5514             case RELEASE:
5515             case RELIES_ON:
5516             case RENAME:
5517             case RESULT:
5518             case RETURN:
5519             case RETURNING:
5520             case REVERSE:
5521             case ROLLBACK:
5522             case ROW:
5523             case ROWS:
5524             case ROWID:
5525             case ROWNUM:
5526             case ROWTYPE:
5527             case SAVE:
5528             case SAVEPOINT:
5529             case SECOND:
5530             case SELECT:
5531             case SELF:
5532             case SEPARATE:
5533             case SET:
5534             case SHARE:
5535             case SMALLINT:
5536             case SPACE:
5537             case SQL:
5538             case SQLCODE:
5539             case SQLERRM:
5540             case START:
5541             case STATIC:
5542             case STDDEV:
5543             case SUBTYPE:
5544             case SUBSTITUTABLE:
5545             case SUCCESSFUL:
5546             case SUM:
5547             case SYNONYM:
5548             case SYSDATE:
5549             case SYS_REFCURSOR:
5550             case TABLE:
5551             case TEMPORARY:
5552             case THEN:
5553             case TIME:
5554             case TIMESTAMP:
5555             case TIMEZONE_REGION:
5556             case TIMEZONE_ABBR:
5557             case TIMEZONE_MINUTE:
5558             case TIMEZONE_HOUR:
5559             case TO:
5560             case TRANSACTION:
5561             case TRIGGER:
5562             case TRUE:
5563             case TYPE:
5564             case UI:
5565             case UNDER:
5566             case USING:
5567             case WHILE:
5568             case YES:
5569             case SHOW:
5570             case A:
5571             case UPDATE:
5572             case VARCHAR:
5573             case VARCHAR2:
5574             case DOUBLE:
5575             case DEC:
5576             case PRECISION:
5577             case INT:
5578             case NUMERIC:
5579             case SIGNTYPE:
5580             case NCHAR:
5581             case NVARCHAR2:
5582             case STRING:
5583             case UROWID:
5584             case VARRAY:
5585             case VARYING:
5586             case BFILE:
5587             case BLOB:
5588             case CLOB:
5589             case NCLOB:
5590             case YEAR:
5591             case LOCAL:
5592             case WITH:
5593             case ZONE:
5594             case CHARACTER:
5595             case AFTER:
5596             case BEFORE:
5597             case OLD:
5598             case PARENT:
5599             case CC_IF:
5600             case ANALYZE:
5601             case ASSOCIATE:
5602             case AUDIT:
5603             case COMPOUND:
5604             case DATABASE:
5605             case CALL:
5606             case DDL:
5607             case DISASSOCIATE:
5608             case EACH:
5609             case FOLLOWS:
5610             case LOGOFF:
5611             case LOGON:
5612             case NESTED:
5613             case NOAUDIT:
5614             case SCHEMA:
5615             case SERVERERROR:
5616             case SHUTDOWN:
5617             case STARTUP:
5618             case STATEMENT:
5619             case STATISTICS:
5620             case SUSPEND:
5621             case TRUNCATE:
5622             case WRAPPED:
5623             case LIBRARY:
5624             case NAME:
5625             case STRUCT:
5626             case CONTEXT:
5627             case PARAMETERS:
5628             case LENGTH:
5629             case TDO:
5630             case MAXLEN:
5631             case CHARSETID:
5632             case CHARSETFORM:
5633             case ACCEPT:
5634             case ACCESSIBLE:
5635             case COPY:
5636             case DEFINE:
5637             case DISCONNECT:
5638             case HOST:
5639             case PRINT:
5640             case QUIT:
5641             case REMARK:
5642             case UNDEFINE:
5643             case VARIABLE:
5644             case WHENEVER:
5645             case ATTACH:
5646             case CAST:
5647             case TREAT:
5648             case TRIM:
5649             case LEFT:
5650             case RIGHT:
5651             case BOTH:
5652             case EMPTY:
5653             case MULTISET:
5654             case SUBMULTISET:
5655             case LEADING:
5656             case TRAILING:
5657             case CHAR_CS:
5658             case NCHAR_CS:
5659             case DBTIMEZONE:
5660             case SESSIONTIMEZONE:
5661             case AUTHENTICATED:
5662             case LINK:
5663             case SHARED:
5664             case DIRECTORY:
5665             case USER:
5666             case IDENTIFIER:
5667             case QUOTED_LITERAL:
5668             case SQLDATA_CLASS:
5669             case CUSTOMDATUM_CLASS:
5670             case ORADATA_CLASS:
5671             case JAVA_INTERFACE_CLASS:
5672               DeclarativeSection();
5673               jj_consume_token(BEGIN);
5674               switch (jj_nt.kind) {
5675               case PRAGMA:
5676                 Pragma();
5677                 break;
5678               default:
5679                 jj_la1[64] = jj_gen;
5680                 ;
5681               }
5682               label_16:
5683               while (true) {
5684                 switch (jj_nt.kind) {
5685                 case 5:
5686                 case 16:
5687                 case 17:
5688                 case 21:
5689                 case REPLACE:
5690                 case DEFINER:
5691                 case CURRENT_USER:
5692                 case LANGUAGE:
5693                 case INLINE:
5694                 case ADD:
5695                 case AGGREGATE:
5696                 case ARRAY:
5697                 case AT:
5698                 case ATTRIBUTE:
5699                 case AUTHID:
5700                 case BEGIN:
5701                 case BODY:
5702                 case BULK:
5703                 case BYTE:
5704                 case CASCADE:
5705                 case CASE:
5706                 case CLOSE:
5707                 case COALESCE:
5708                 case COLLECT:
5709                 case COLUMN:
5710                 case COMMENT:
5711                 case COMMIT:
5712                 case CONSTRUCTOR:
5713                 case CONTINUE:
5714                 case CONVERT:
5715                 case CURRENT:
5716                 case CURSOR:
5717                 case DATA:
5718                 case DATE:
5719                 case DAY:
5720                 case DECLARE:
5721                 case DELETE:
5722                 case DISABLE:
5723                 case EDITIONABLE:
5724                 case ELEMENT:
5725                 case ENABLE:
5726                 case ESCAPE:
5727                 case EXCEPT:
5728                 case EXCEPTIONS:
5729                 case EXECUTE:
5730                 case EXIT:
5731                 case EXTERNAL:
5732                 case EXTENDS:
5733                 case EXTRACT:
5734                 case FALSE:
5735                 case FETCH:
5736                 case FINAL:
5737                 case FOR:
5738                 case FORALL:
5739                 case FORCE:
5740                 case FUNCTION:
5741                 case GLOBAL:
5742                 case GOTO:
5743                 case HASH:
5744                 case HEAP:
5745                 case HOUR:
5746                 case IF:
5747                 case IMMEDIATE:
5748                 case INDICES:
5749                 case INDEXTYPE:
5750                 case INDICATOR:
5751                 case INSERT:
5752                 case INSTANTIABLE:
5753                 case INTERVAL:
5754                 case INVALIDATE:
5755                 case ISOLATION:
5756                 case JAVA:
5757                 case LEVEL:
5758                 case LIMIT:
5759                 case LOCK:
5760                 case LOOP:
5761                 case MAP:
5762                 case MAX:
5763                 case MEMBER:
5764                 case MERGE:
5765                 case MIN:
5766                 case MINUTE:
5767                 case MLSLABEL:
5768                 case MODIFY:
5769                 case MOD:
5770                 case MONTH:
5771                 case NATURAL:
5772                 case NEW:
5773                 case NEW_DOT:
5774                 case NO:
5775                 case NONEDITIONABLE:
5776                 case NOT:
5777                 case NULL:
5778                 case NULLIF:
5779                 case OBJECT:
5780                 case OID:
5781                 case OPAQUE:
5782                 case OPEN:
5783                 case OPERATOR:
5784                 case ORGANIZATION:
5785                 case OTHERS:
5786                 case OVERRIDING:
5787                 case PACKAGE:
5788                 case PARTITION:
5789                 case PIPE:
5790                 case PRAGMA:
5791                 case PRESERVE:
5792                 case PRIVATE:
5793                 case PROCEDURE:
5794                 case RAISE:
5795                 case RANGE:
5796                 case RAW:
5797                 case REAL:
5798                 case RECORD:
5799                 case REF:
5800                 case RELEASE:
5801                 case RELIES_ON:
5802                 case RENAME:
5803                 case RESULT:
5804                 case RETURN:
5805                 case RETURNING:
5806                 case REVERSE:
5807                 case ROLLBACK:
5808                 case ROW:
5809                 case ROWS:
5810                 case ROWID:
5811                 case ROWNUM:
5812                 case SAVE:
5813                 case SAVEPOINT:
5814                 case SECOND:
5815                 case SELECT:
5816                 case SELF:
5817                 case SET:
5818                 case SPACE:
5819                 case SQL:
5820                 case SQLCODE:
5821                 case SQLERRM:
5822                 case STATIC:
5823                 case SUBTYPE:
5824                 case SUBSTITUTABLE:
5825                 case SUCCESSFUL:
5826                 case SYSDATE:
5827                 case SYS_REFCURSOR:
5828                 case TEMPORARY:
5829                 case TIME:
5830                 case TIMESTAMP:
5831                 case TIMEZONE_REGION:
5832                 case TIMEZONE_ABBR:
5833                 case TIMEZONE_MINUTE:
5834                 case TIMEZONE_HOUR:
5835                 case TRANSACTION:
5836                 case TRUE:
5837                 case TYPE:
5838                 case UNDER:
5839                 case USING:
5840                 case WHILE:
5841                 case YES:
5842                 case SHOW:
5843                 case A:
5844                 case UPDATE:
5845                 case DOUBLE:
5846                 case DEC:
5847                 case PRECISION:
5848                 case INT:
5849                 case NUMERIC:
5850                 case NCHAR:
5851                 case NVARCHAR2:
5852                 case STRING:
5853                 case UROWID:
5854                 case VARRAY:
5855                 case VARYING:
5856                 case BFILE:
5857                 case BLOB:
5858                 case CLOB:
5859                 case NCLOB:
5860                 case YEAR:
5861                 case LOCAL:
5862                 case WITH:
5863                 case ZONE:
5864                 case CHARACTER:
5865                 case AFTER:
5866                 case BEFORE:
5867                 case OLD:
5868                 case PARENT:
5869                 case CC_IF:
5870                 case CC_ERROR:
5871                 case ANALYZE:
5872                 case ASSOCIATE:
5873                 case AUDIT:
5874                 case COMPOUND:
5875                 case DATABASE:
5876                 case CALL:
5877                 case DDL:
5878                 case DISASSOCIATE:
5879                 case EACH:
5880                 case FOLLOWS:
5881                 case LOGOFF:
5882                 case LOGON:
5883                 case NESTED:
5884                 case NOAUDIT:
5885                 case SCHEMA:
5886                 case SERVERERROR:
5887                 case SHUTDOWN:
5888                 case STARTUP:
5889                 case STATEMENT:
5890                 case STATISTICS:
5891                 case SUSPEND:
5892                 case TRUNCATE:
5893                 case WRAPPED:
5894                 case LIBRARY:
5895                 case NAME:
5896                 case STRUCT:
5897                 case CONTEXT:
5898                 case PARAMETERS:
5899                 case LENGTH:
5900                 case TDO:
5901                 case MAXLEN:
5902                 case CHARSETID:
5903                 case CHARSETFORM:
5904                 case ACCEPT:
5905                 case ACCESSIBLE:
5906                 case COPY:
5907                 case DEFINE:
5908                 case DISCONNECT:
5909                 case HOST:
5910                 case PRINT:
5911                 case QUIT:
5912                 case REMARK:
5913                 case UNDEFINE:
5914                 case VARIABLE:
5915                 case WHENEVER:
5916                 case ATTACH:
5917                 case CAST:
5918                 case TREAT:
5919                 case TRIM:
5920                 case LEFT:
5921                 case RIGHT:
5922                 case BOTH:
5923                 case EMPTY:
5924                 case MULTISET:
5925                 case SUBMULTISET:
5926                 case LEADING:
5927                 case TRAILING:
5928                 case CHAR_CS:
5929                 case NCHAR_CS:
5930                 case DBTIMEZONE:
5931                 case SESSIONTIMEZONE:
5932                 case AUTHENTICATED:
5933                 case LINK:
5934                 case SHARED:
5935                 case DIRECTORY:
5936                 case USER:
5937                 case IDENTIFIER:
5938                 case UNSIGNED_NUMERIC_LITERAL:
5939                 case CHARACTER_LITERAL:
5940                 case STRING_LITERAL:
5941                 case QUOTED_LITERAL:
5942                   ;
5943                   break;
5944                 default:
5945                   jj_la1[65] = jj_gen;
5946                   break label_16;
5947                 }
5948                 Statement();
5949               }
5950               switch (jj_nt.kind) {
5951               case EXCEPTION:
5952                 ExceptionHandler();
5953                 break;
5954               default:
5955                 jj_la1[66] = jj_gen;
5956                 ;
5957               }
5958               jj_consume_token(END);
5959               switch (jj_nt.kind) {
5960               case REPLACE:
5961               case DEFINER:
5962               case CURRENT_USER:
5963               case SERIALLY_REUSABLE:
5964               case RESTRICT_REFERENCES:
5965               case EXCEPTION_INIT:
5966               case AUTONOMOUS_TRANSACTION:
5967               case LANGUAGE:
5968               case INLINE:
5969               case ADD:
5970               case AGGREGATE:
5971               case ALL:
5972               case ALTER:
5973               case AND:
5974               case ANY:
5975               case ARRAY:
5976               case AS:
5977               case ASC:
5978               case AT:
5979               case ATTRIBUTE:
5980               case AUTHID:
5981               case AVG:
5982               case BETWEEN:
5983               case BINARY_INTEGER:
5984               case BODY:
5985               case BOOLEAN:
5986               case BULK:
5987               case BY:
5988               case BYTE:
5989               case CASCADE:
5990               case CASE:
5991               case CHAR:
5992               case CHAR_BASE:
5993               case CHECK:
5994               case CLOSE:
5995               case CLUSTER:
5996               case COALESCE:
5997               case COLLECT:
5998               case COLUMN:
5999               case COMMENT:
6000               case COMMIT:
6001               case COMPRESS:
6002               case CONNECT:
6003               case CONSTANT:
6004               case CONSTRUCTOR:
6005               case CONTINUE:
6006               case CONVERT:
6007               case CREATE:
6008               case CURRENT:
6009               case CURRVAL:
6010               case CURSOR:
6011               case DATA:
6012               case DATE:
6013               case DAY:
6014               case DECLARE:
6015               case DECIMAL:
6016               case _DEFAULT:
6017               case DELETE:
6018               case DESC:
6019               case DISABLE:
6020               case DISTINCT:
6021               case DO:
6022               case DROP:
6023               case EDITIONABLE:
6024               case ELEMENT:
6025               case ELSE:
6026               case ELSIF:
6027               case ENABLE:
6028               case ESCAPE:
6029               case EXCEPT:
6030               case EXCEPTION:
6031               case EXCEPTIONS:
6032               case EXCLUSIVE:
6033               case EXECUTE:
6034               case EXISTS:
6035               case EXIT:
6036               case EXTERNAL:
6037               case EXTENDS:
6038               case EXTRACT:
6039               case FALSE:
6040               case FETCH:
6041               case FINAL:
6042               case FLOAT:
6043               case FOR:
6044               case FORALL:
6045               case FORCE:
6046               case FROM:
6047               case FUNCTION:
6048               case GLOBAL:
6049               case GOTO:
6050               case GROUP:
6051               case HASH:
6052               case HAVING:
6053               case HEAP:
6054               case HOUR:
6055               case IF:
6056               case IMMEDIATE:
6057               case IN:
6058               case INDEX:
6059               case INDICES:
6060               case INDEXTYPE:
6061               case INDICATOR:
6062               case INSERT:
6063               case INSTANTIABLE:
6064               case INTEGER:
6065               case INTERFACE:
6066               case INTERSECT:
6067               case INTERVAL:
6068               case INTO:
6069               case INVALIDATE:
6070               case IS:
6071               case ISOLATION:
6072               case JAVA:
6073               case LEVEL:
6074               case LIKE:
6075               case LIMIT:
6076               case LIMITED:
6077               case LOCK:
6078               case LONG:
6079               case LOOP:
6080               case MAP:
6081               case MAX:
6082               case MEMBER:
6083               case MERGE:
6084               case MIN:
6085               case MINUS:
6086               case MINUTE:
6087               case MLSLABEL:
6088               case MODIFY:
6089               case MOD:
6090               case MODE:
6091               case MONTH:
6092               case NATURAL:
6093               case NATURALN:
6094               case NEW:
6095               case NEXTVAL:
6096               case NO:
6097               case NOCOPY:
6098               case NONEDITIONABLE:
6099               case NOT:
6100               case NOWAIT:
6101               case NULL:
6102               case NULLIF:
6103               case NUMBER:
6104               case BFILE_BASE:
6105               case BLOB_BASE:
6106               case CLOB_BASE:
6107               case DATE_BASE:
6108               case NUMBER_BASE:
6109               case OBJECT:
6110               case OCIROWID:
6111               case OF:
6112               case OID:
6113               case ON:
6114               case OPAQUE:
6115               case OPEN:
6116               case OPERATOR:
6117               case OPTION:
6118               case OR:
6119               case ORDER:
6120               case ORGANIZATION:
6121               case OTHERS:
6122               case OUT:
6123               case OVERRIDING:
6124               case PACKAGE:
6125               case PARTITION:
6126               case PCTFREE:
6127               case PLS_INTEGER:
6128               case POSITIVE:
6129               case POSITIVEN:
6130               case PRESERVE:
6131               case PRIOR:
6132               case PROMPT:
6133               case PRIVATE:
6134               case PROCEDURE:
6135               case PUBLIC:
6136               case RAISE:
6137               case RANGE:
6138               case RAW:
6139               case REAL:
6140               case RECORD:
6141               case REF:
6142               case RELEASE:
6143               case RELIES_ON:
6144               case RENAME:
6145               case RESULT:
6146               case RETURN:
6147               case RETURNING:
6148               case REVERSE:
6149               case ROLLBACK:
6150               case ROW:
6151               case ROWS:
6152               case ROWID:
6153               case ROWNUM:
6154               case ROWTYPE:
6155               case SAVE:
6156               case SAVEPOINT:
6157               case SECOND:
6158               case SELECT:
6159               case SELF:
6160               case SEPARATE:
6161               case SET:
6162               case SHARE:
6163               case SMALLINT:
6164               case SPACE:
6165               case SQL:
6166               case SQLCODE:
6167               case SQLERRM:
6168               case START:
6169               case STATIC:
6170               case STDDEV:
6171               case SUBTYPE:
6172               case SUBSTITUTABLE:
6173               case SUCCESSFUL:
6174               case SUM:
6175               case SYNONYM:
6176               case SYSDATE:
6177               case SYS_REFCURSOR:
6178               case TABLE:
6179               case TEMPORARY:
6180               case THEN:
6181               case TIME:
6182               case TIMESTAMP:
6183               case TIMEZONE_REGION:
6184               case TIMEZONE_ABBR:
6185               case TIMEZONE_MINUTE:
6186               case TIMEZONE_HOUR:
6187               case TO:
6188               case TRANSACTION:
6189               case TRIGGER:
6190               case TRUE:
6191               case TYPE:
6192               case UI:
6193               case UNDER:
6194               case USING:
6195               case WHILE:
6196               case YES:
6197               case SHOW:
6198               case A:
6199               case UPDATE:
6200               case VARCHAR:
6201               case VARCHAR2:
6202               case DOUBLE:
6203               case DEC:
6204               case PRECISION:
6205               case INT:
6206               case NUMERIC:
6207               case SIGNTYPE:
6208               case NCHAR:
6209               case NVARCHAR2:
6210               case STRING:
6211               case UROWID:
6212               case VARRAY:
6213               case VARYING:
6214               case BFILE:
6215               case BLOB:
6216               case CLOB:
6217               case NCLOB:
6218               case YEAR:
6219               case LOCAL:
6220               case WITH:
6221               case ZONE:
6222               case CHARACTER:
6223               case AFTER:
6224               case BEFORE:
6225               case OLD:
6226               case PARENT:
6227               case ANALYZE:
6228               case ASSOCIATE:
6229               case AUDIT:
6230               case COMPOUND:
6231               case DATABASE:
6232               case CALL:
6233               case DDL:
6234               case DISASSOCIATE:
6235               case EACH:
6236               case FOLLOWS:
6237               case LOGOFF:
6238               case LOGON:
6239               case NESTED:
6240               case NOAUDIT:
6241               case SCHEMA:
6242               case SERVERERROR:
6243               case SHUTDOWN:
6244               case STARTUP:
6245               case STATEMENT:
6246               case STATISTICS:
6247               case SUSPEND:
6248               case TRUNCATE:
6249               case WRAPPED:
6250               case LIBRARY:
6251               case NAME:
6252               case STRUCT:
6253               case CONTEXT:
6254               case PARAMETERS:
6255               case LENGTH:
6256               case TDO:
6257               case MAXLEN:
6258               case CHARSETID:
6259               case CHARSETFORM:
6260               case ACCEPT:
6261               case ACCESSIBLE:
6262               case COPY:
6263               case DEFINE:
6264               case DISCONNECT:
6265               case HOST:
6266               case PRINT:
6267               case QUIT:
6268               case REMARK:
6269               case UNDEFINE:
6270               case VARIABLE:
6271               case WHENEVER:
6272               case ATTACH:
6273               case CAST:
6274               case TREAT:
6275               case TRIM:
6276               case LEFT:
6277               case RIGHT:
6278               case BOTH:
6279               case EMPTY:
6280               case MULTISET:
6281               case SUBMULTISET:
6282               case LEADING:
6283               case TRAILING:
6284               case CHAR_CS:
6285               case NCHAR_CS:
6286               case DBTIMEZONE:
6287               case SESSIONTIMEZONE:
6288               case AUTHENTICATED:
6289               case LINK:
6290               case SHARED:
6291               case DIRECTORY:
6292               case USER:
6293               case IDENTIFIER:
6294               case QUOTED_LITERAL:
6295               case SQLDATA_CLASS:
6296               case CUSTOMDATUM_CLASS:
6297               case ORADATA_CLASS:
6298               case JAVA_INTERFACE_CLASS:
6299                 ID();
6300                 break;
6301               default:
6302                 jj_la1[67] = jj_gen;
6303                 ;
6304               }
6305               break;
6306             default:
6307               jj_la1[68] = jj_gen;
6308               jj_consume_token(-1);
6309               throw new ParseException();
6310             }
6311           }
6312           break;
6313         default:
6314           jj_la1[69] = jj_gen;
6315           ;
6316         }
6317         jj_consume_token(4);
6318         break;
6319       default:
6320         jj_la1[70] = jj_gen;
6321         jj_consume_token(-1);
6322         throw new ParseException();
6323       }
6324         jjtree.closeNodeScope(jjtn000, true);
6325         jjtc000 = false;
6326         {if (true) return jjtn000 ;}
6327     } catch (Throwable jjte000) {
6328           if (jjtc000) {
6329             jjtree.clearNodeScope(jjtn000);
6330             jjtc000 = false;
6331           } else {
6332             jjtree.popNode();
6333           }
6334           if (jjte000 instanceof RuntimeException) {
6335             {if (true) throw (RuntimeException)jjte000;}
6336           }
6337           if (jjte000 instanceof ParseException) {
6338             {if (true) throw (ParseException)jjte000;}
6339           }
6340           {if (true) throw (Error)jjte000;}
6341     } finally {
6342           if (jjtc000) {
6343             jjtree.closeNodeScope(jjtn000, true);
6344           }
6345     }
6346     throw new Error("Missing return statement in function");
6347   }
6348 
6349   final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350  /*@bgen(jjtree) ObjectNameDeclaration */
6351  ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352  boolean jjtc000 = true;
6353  jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354     try {
6355       if (jj_2_22(2)) {
6356         schemaName = ID();
6357         jj_consume_token(3);
6358       } else {
6359         ;
6360       }
6361       objectName = ID();
6362     jjtn000.setImage(  (null == schemaName) ?  objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() )  )  ;
6363     jjtree.closeNodeScope(jjtn000, true);
6364     jjtc000 = false;
6365     {if (true) return jjtn000 ;}
6366     } catch (Throwable jjte000) {
6367     if (jjtc000) {
6368       jjtree.clearNodeScope(jjtn000);
6369       jjtc000 = false;
6370     } else {
6371       jjtree.popNode();
6372     }
6373     if (jjte000 instanceof RuntimeException) {
6374       {if (true) throw (RuntimeException)jjte000;}
6375     }
6376     if (jjte000 instanceof ParseException) {
6377       {if (true) throw (ParseException)jjte000;}
6378     }
6379     {if (true) throw (Error)jjte000;}
6380     } finally {
6381     if (jjtc000) {
6382       jjtree.closeNodeScope(jjtn000, true);
6383     }
6384     }
6385     throw new Error("Missing return statement in function");
6386   }
6387 
6388   final public ASTFormalParameter FormalParameter() throws ParseException {
6389  /*@bgen(jjtree) FormalParameter */
6390  ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391  boolean jjtc000 = true;
6392  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393     try {
6394       simpleNode = ID();
6395       if (jj_2_25(2)) {
6396         if (jj_2_24(2)) {
6397           switch (jj_nt.kind) {
6398           case OUT:
6399             jj_consume_token(OUT);
6400             break;
6401           case IN:
6402             jj_consume_token(IN);
6403             jj_consume_token(OUT);
6404             break;
6405           default:
6406             jj_la1[71] = jj_gen;
6407             jj_consume_token(-1);
6408             throw new ParseException();
6409           }
6410           if (jj_2_23(2)) {
6411             jj_consume_token(NOCOPY);
6412           } else {
6413             ;
6414           }
6415         } else {
6416           switch (jj_nt.kind) {
6417           case IN:
6418             jj_consume_token(IN);
6419             break;
6420           default:
6421             jj_la1[72] = jj_gen;
6422             jj_consume_token(-1);
6423             throw new ParseException();
6424           }
6425         }
6426       } else {
6427         ;
6428       }
6429       switch (jj_nt.kind) {
6430       case 8:
6431         jj_consume_token(8);
6432         break;
6433       case REPLACE:
6434       case DEFINER:
6435       case CURRENT_USER:
6436       case LANGUAGE:
6437       case INLINE:
6438       case ADD:
6439       case AGGREGATE:
6440       case ARRAY:
6441       case AT:
6442       case ATTRIBUTE:
6443       case AUTHID:
6444       case BINARY_INTEGER:
6445       case BODY:
6446       case BOOLEAN:
6447       case BULK:
6448       case BYTE:
6449       case CASCADE:
6450       case CHAR:
6451       case CHAR_BASE:
6452       case CLOSE:
6453       case COALESCE:
6454       case COLLECT:
6455       case COLUMN:
6456       case COMMENT:
6457       case COMMIT:
6458       case CONSTRUCTOR:
6459       case CONTINUE:
6460       case CONVERT:
6461       case CURRENT:
6462       case CURSOR:
6463       case DATA:
6464       case DATE:
6465       case DAY:
6466       case DECIMAL:
6467       case DISABLE:
6468       case EDITIONABLE:
6469       case ELEMENT:
6470       case ENABLE:
6471       case ESCAPE:
6472       case EXCEPT:
6473       case EXCEPTIONS:
6474       case EXIT:
6475       case EXTERNAL:
6476       case EXTENDS:
6477       case EXTRACT:
6478       case FALSE:
6479       case FINAL:
6480       case FLOAT:
6481       case FORCE:
6482       case FUNCTION:
6483       case GLOBAL:
6484       case HASH:
6485       case HEAP:
6486       case HOUR:
6487       case IMMEDIATE:
6488       case INDICES:
6489       case INDEXTYPE:
6490       case INDICATOR:
6491       case INSTANTIABLE:
6492       case INTEGER:
6493       case INTERVAL:
6494       case INVALIDATE:
6495       case ISOLATION:
6496       case JAVA:
6497       case LEVEL:
6498       case LIMIT:
6499       case LONG:
6500       case LOOP:
6501       case MAP:
6502       case MAX:
6503       case MEMBER:
6504       case MERGE:
6505       case MIN:
6506       case MINUTE:
6507       case MLSLABEL:
6508       case MODIFY:
6509       case MOD:
6510       case MONTH:
6511       case NATURAL:
6512       case NATURALN:
6513       case NEW:
6514       case NO:
6515       case NONEDITIONABLE:
6516       case NULLIF:
6517       case NUMBER:
6518       case BFILE_BASE:
6519       case BLOB_BASE:
6520       case CLOB_BASE:
6521       case DATE_BASE:
6522       case NUMBER_BASE:
6523       case OBJECT:
6524       case OID:
6525       case OPAQUE:
6526       case OPEN:
6527       case OPERATOR:
6528       case ORGANIZATION:
6529       case OTHERS:
6530       case OVERRIDING:
6531       case PACKAGE:
6532       case PARTITION:
6533       case PLS_INTEGER:
6534       case POSITIVE:
6535       case POSITIVEN:
6536       case PRESERVE:
6537       case PRIVATE:
6538       case PROCEDURE:
6539       case RANGE:
6540       case RAW:
6541       case REAL:
6542       case RECORD:
6543       case REF:
6544       case RELEASE:
6545       case RELIES_ON:
6546       case RENAME:
6547       case RESULT:
6548       case RETURN:
6549       case RETURNING:
6550       case REVERSE:
6551       case ROLLBACK:
6552       case ROW:
6553       case ROWS:
6554       case ROWID:
6555       case ROWNUM:
6556       case SAVE:
6557       case SAVEPOINT:
6558       case SECOND:
6559       case SELF:
6560       case SET:
6561       case SMALLINT:
6562       case SPACE:
6563       case SQL:
6564       case SQLCODE:
6565       case SQLERRM:
6566       case STATIC:
6567       case SUBTYPE:
6568       case SUBSTITUTABLE:
6569       case SUCCESSFUL:
6570       case SYSDATE:
6571       case SYS_REFCURSOR:
6572       case TEMPORARY:
6573       case TIME:
6574       case TIMESTAMP:
6575       case TIMEZONE_REGION:
6576       case TIMEZONE_ABBR:
6577       case TIMEZONE_MINUTE:
6578       case TIMEZONE_HOUR:
6579       case TRANSACTION:
6580       case TRUE:
6581       case TYPE:
6582       case UNDER:
6583       case USING:
6584       case YES:
6585       case SHOW:
6586       case A:
6587       case VARCHAR:
6588       case VARCHAR2:
6589       case DOUBLE:
6590       case DEC:
6591       case PRECISION:
6592       case INT:
6593       case NUMERIC:
6594       case SIGNTYPE:
6595       case NCHAR:
6596       case NVARCHAR2:
6597       case STRING:
6598       case UROWID:
6599       case VARRAY:
6600       case VARYING:
6601       case BFILE:
6602       case BLOB:
6603       case CLOB:
6604       case NCLOB:
6605       case YEAR:
6606       case LOCAL:
6607       case ZONE:
6608       case CHARACTER:
6609       case AFTER:
6610       case BEFORE:
6611       case OLD:
6612       case PARENT:
6613       case CC_IF:
6614       case ANALYZE:
6615       case ASSOCIATE:
6616       case AUDIT:
6617       case COMPOUND:
6618       case DATABASE:
6619       case CALL:
6620       case DDL:
6621       case DISASSOCIATE:
6622       case EACH:
6623       case FOLLOWS:
6624       case LOGOFF:
6625       case LOGON:
6626       case NESTED:
6627       case NOAUDIT:
6628       case SCHEMA:
6629       case SERVERERROR:
6630       case SHUTDOWN:
6631       case STARTUP:
6632       case STATEMENT:
6633       case STATISTICS:
6634       case SUSPEND:
6635       case TRUNCATE:
6636       case WRAPPED:
6637       case LIBRARY:
6638       case NAME:
6639       case STRUCT:
6640       case CONTEXT:
6641       case PARAMETERS:
6642       case LENGTH:
6643       case TDO:
6644       case MAXLEN:
6645       case CHARSETID:
6646       case CHARSETFORM:
6647       case ACCEPT:
6648       case ACCESSIBLE:
6649       case COPY:
6650       case DEFINE:
6651       case DISCONNECT:
6652       case HOST:
6653       case PRINT:
6654       case QUIT:
6655       case REMARK:
6656       case UNDEFINE:
6657       case VARIABLE:
6658       case WHENEVER:
6659       case ATTACH:
6660       case CAST:
6661       case TREAT:
6662       case TRIM:
6663       case LEFT:
6664       case RIGHT:
6665       case BOTH:
6666       case EMPTY:
6667       case MULTISET:
6668       case SUBMULTISET:
6669       case LEADING:
6670       case TRAILING:
6671       case CHAR_CS:
6672       case NCHAR_CS:
6673       case DBTIMEZONE:
6674       case SESSIONTIMEZONE:
6675       case AUTHENTICATED:
6676       case LINK:
6677       case SHARED:
6678       case DIRECTORY:
6679       case USER:
6680       case IDENTIFIER:
6681       case QUOTED_LITERAL:
6682         Datatype();
6683         break;
6684       default:
6685         jj_la1[73] = jj_gen;
6686         jj_consume_token(-1);
6687         throw new ParseException();
6688       }
6689       switch (jj_nt.kind) {
6690       case 9:
6691       case _DEFAULT:
6692         switch (jj_nt.kind) {
6693         case 9:
6694           jj_consume_token(9);
6695           jj_consume_token(10);
6696           break;
6697         case _DEFAULT:
6698           jj_consume_token(_DEFAULT);
6699           break;
6700         default:
6701           jj_la1[74] = jj_gen;
6702           jj_consume_token(-1);
6703           throw new ParseException();
6704         }
6705         Expression();
6706         break;
6707       default:
6708         jj_la1[75] = jj_gen;
6709         ;
6710       }
6711      jjtree.closeNodeScope(jjtn000, true);
6712      jjtc000 = false;
6713      jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6714     } catch (Throwable jjte000) {
6715      if (jjtc000) {
6716        jjtree.clearNodeScope(jjtn000);
6717        jjtc000 = false;
6718      } else {
6719        jjtree.popNode();
6720      }
6721      if (jjte000 instanceof RuntimeException) {
6722        {if (true) throw (RuntimeException)jjte000;}
6723      }
6724      if (jjte000 instanceof ParseException) {
6725        {if (true) throw (ParseException)jjte000;}
6726      }
6727      {if (true) throw (Error)jjte000;}
6728     } finally {
6729      if (jjtc000) {
6730        jjtree.closeNodeScope(jjtn000, true);
6731      }
6732     }
6733     throw new Error("Missing return statement in function");
6734   }
6735 
6736   final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737  /*@bgen(jjtree) MethodDeclaration */
6738   ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739   boolean jjtc000 = true;
6740   jjtree.openNodeScope(jjtn000);
6741     try {
6742       switch (jj_nt.kind) {
6743       case CREATE:
6744       case FUNCTION:
6745       case PROCEDURE:
6746         ProgramUnit();
6747         break;
6748       case CONSTRUCTOR:
6749       case FINAL:
6750       case INSTANTIABLE:
6751       case MAP:
6752       case MEMBER:
6753       case NOT:
6754       case ORDER:
6755       case OVERRIDING:
6756       case STATIC:
6757         TypeMethod();
6758         break;
6759       default:
6760         jj_la1[76] = jj_gen;
6761         jj_consume_token(-1);
6762         throw new ParseException();
6763       }
6764     jjtree.closeNodeScope(jjtn000, true);
6765     jjtc000 = false;
6766     {if (true) return jjtn000 ;}
6767     } catch (Throwable jjte000) {
6768     if (jjtc000) {
6769       jjtree.clearNodeScope(jjtn000);
6770       jjtc000 = false;
6771     } else {
6772       jjtree.popNode();
6773     }
6774     if (jjte000 instanceof RuntimeException) {
6775       {if (true) throw (RuntimeException)jjte000;}
6776     }
6777     if (jjte000 instanceof ParseException) {
6778       {if (true) throw (ParseException)jjte000;}
6779     }
6780     {if (true) throw (Error)jjte000;}
6781     } finally {
6782     if (jjtc000) {
6783       jjtree.closeNodeScope(jjtn000, true);
6784     }
6785     }
6786     throw new Error("Missing return statement in function");
6787   }
6788 
6789   final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790  /*@bgen(jjtree) MethodDeclarator */
6791  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792  boolean jjtc000 = true;
6793  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794     try {
6795       switch (jj_nt.kind) {
6796       case FUNCTION:
6797         jj_consume_token(FUNCTION);
6798         simpleNode = ObjectNameDeclaration();
6799         switch (jj_nt.kind) {
6800         case 5:
6801           FormalParameters();
6802           break;
6803         default:
6804           jj_la1[77] = jj_gen;
6805           ;
6806         }
6807         Token nextToken;
6808         nextToken = getToken(1); //ReadAhead
6809         if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810             &&
6811             !nextToken.image.equalsIgnoreCase("RETURN")
6812            )
6813         {
6814           {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815                                               + nextToken.image
6816                                               + "\u005c" at line "+nextToken.beginLine
6817                                               + ", column "+nextToken.beginColumn
6818                                              );}
6819         }
6820         switch (jj_nt.kind) {
6821         case RETURN:
6822           jj_consume_token(RETURN);
6823           Datatype();
6824           break;
6825         default:
6826           jj_la1[78] = jj_gen;
6827           ;
6828         }
6829         break;
6830       case PROCEDURE:
6831         jj_consume_token(PROCEDURE);
6832         simpleNode = ObjectNameDeclaration();
6833         switch (jj_nt.kind) {
6834         case 5:
6835           FormalParameters();
6836           break;
6837         default:
6838           jj_la1[79] = jj_gen;
6839           ;
6840         }
6841         break;
6842       default:
6843         jj_la1[80] = jj_gen;
6844         jj_consume_token(-1);
6845         throw new ParseException();
6846       }
6847     jjtree.closeNodeScope(jjtn000, true);
6848     jjtc000 = false;
6849     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6850     } catch (Throwable jjte000) {
6851     if (jjtc000) {
6852       jjtree.clearNodeScope(jjtn000);
6853       jjtc000 = false;
6854     } else {
6855       jjtree.popNode();
6856     }
6857     if (jjte000 instanceof RuntimeException) {
6858       {if (true) throw (RuntimeException)jjte000;}
6859     }
6860     if (jjte000 instanceof ParseException) {
6861       {if (true) throw (ParseException)jjte000;}
6862     }
6863     {if (true) throw (Error)jjte000;}
6864     } finally {
6865     if (jjtc000) {
6866       jjtree.closeNodeScope(jjtn000, true);
6867     }
6868     }
6869     throw new Error("Missing return statement in function");
6870   }
6871 
6872   final public ASTFormalParameters FormalParameters() throws ParseException {
6873  /*@bgen(jjtree) FormalParameters */
6874  ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875  boolean jjtc000 = true;
6876  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877  StringBuilder sb = new StringBuilder();
6878     try {
6879       jj_consume_token(5);
6880         sb.append("(");
6881       switch (jj_nt.kind) {
6882       case REPLACE:
6883       case DEFINER:
6884       case CURRENT_USER:
6885       case SERIALLY_REUSABLE:
6886       case RESTRICT_REFERENCES:
6887       case EXCEPTION_INIT:
6888       case AUTONOMOUS_TRANSACTION:
6889       case LANGUAGE:
6890       case INLINE:
6891       case ADD:
6892       case AGGREGATE:
6893       case ALL:
6894       case ALTER:
6895       case AND:
6896       case ANY:
6897       case ARRAY:
6898       case AS:
6899       case ASC:
6900       case AT:
6901       case ATTRIBUTE:
6902       case AUTHID:
6903       case AVG:
6904       case BETWEEN:
6905       case BINARY_INTEGER:
6906       case BODY:
6907       case BOOLEAN:
6908       case BULK:
6909       case BY:
6910       case BYTE:
6911       case CASCADE:
6912       case CASE:
6913       case CHAR:
6914       case CHAR_BASE:
6915       case CHECK:
6916       case CLOSE:
6917       case CLUSTER:
6918       case COALESCE:
6919       case COLLECT:
6920       case COLUMN:
6921       case COMMENT:
6922       case COMMIT:
6923       case COMPRESS:
6924       case CONNECT:
6925       case CONSTANT:
6926       case CONSTRUCTOR:
6927       case CONTINUE:
6928       case CONVERT:
6929       case CREATE:
6930       case CURRENT:
6931       case CURRVAL:
6932       case CURSOR:
6933       case DATA:
6934       case DATE:
6935       case DAY:
6936       case DECLARE:
6937       case DECIMAL:
6938       case _DEFAULT:
6939       case DELETE:
6940       case DESC:
6941       case DISABLE:
6942       case DISTINCT:
6943       case DO:
6944       case DROP:
6945       case EDITIONABLE:
6946       case ELEMENT:
6947       case ELSE:
6948       case ELSIF:
6949       case ENABLE:
6950       case ESCAPE:
6951       case EXCEPT:
6952       case EXCEPTION:
6953       case EXCEPTIONS:
6954       case EXCLUSIVE:
6955       case EXECUTE:
6956       case EXISTS:
6957       case EXIT:
6958       case EXTERNAL:
6959       case EXTENDS:
6960       case EXTRACT:
6961       case FALSE:
6962       case FETCH:
6963       case FINAL:
6964       case FLOAT:
6965       case FOR:
6966       case FORALL:
6967       case FORCE:
6968       case FROM:
6969       case FUNCTION:
6970       case GLOBAL:
6971       case GOTO:
6972       case GROUP:
6973       case HASH:
6974       case HAVING:
6975       case HEAP:
6976       case HOUR:
6977       case IF:
6978       case IMMEDIATE:
6979       case IN:
6980       case INDEX:
6981       case INDICES:
6982       case INDEXTYPE:
6983       case INDICATOR:
6984       case INSERT:
6985       case INSTANTIABLE:
6986       case INTEGER:
6987       case INTERFACE:
6988       case INTERSECT:
6989       case INTERVAL:
6990       case INTO:
6991       case INVALIDATE:
6992       case IS:
6993       case ISOLATION:
6994       case JAVA:
6995       case LEVEL:
6996       case LIKE:
6997       case LIMIT:
6998       case LIMITED:
6999       case LOCK:
7000       case LONG:
7001       case LOOP:
7002       case MAP:
7003       case MAX:
7004       case MEMBER:
7005       case MERGE:
7006       case MIN:
7007       case MINUS:
7008       case MINUTE:
7009       case MLSLABEL:
7010       case MODIFY:
7011       case MOD:
7012       case MODE:
7013       case MONTH:
7014       case NATURAL:
7015       case NATURALN:
7016       case NEW:
7017       case NEXTVAL:
7018       case NO:
7019       case NOCOPY:
7020       case NONEDITIONABLE:
7021       case NOT:
7022       case NOWAIT:
7023       case NULL:
7024       case NULLIF:
7025       case NUMBER:
7026       case BFILE_BASE:
7027       case BLOB_BASE:
7028       case CLOB_BASE:
7029       case DATE_BASE:
7030       case NUMBER_BASE:
7031       case OBJECT:
7032       case OCIROWID:
7033       case OF:
7034       case OID:
7035       case ON:
7036       case OPAQUE:
7037       case OPEN:
7038       case OPERATOR:
7039       case OPTION:
7040       case OR:
7041       case ORDER:
7042       case ORGANIZATION:
7043       case OTHERS:
7044       case OUT:
7045       case OVERRIDING:
7046       case PACKAGE:
7047       case PARTITION:
7048       case PCTFREE:
7049       case PLS_INTEGER:
7050       case POSITIVE:
7051       case POSITIVEN:
7052       case PRESERVE:
7053       case PRIOR:
7054       case PROMPT:
7055       case PRIVATE:
7056       case PROCEDURE:
7057       case PUBLIC:
7058       case RAISE:
7059       case RANGE:
7060       case RAW:
7061       case REAL:
7062       case RECORD:
7063       case REF:
7064       case RELEASE:
7065       case RELIES_ON:
7066       case RENAME:
7067       case RESULT:
7068       case RETURN:
7069       case RETURNING:
7070       case REVERSE:
7071       case ROLLBACK:
7072       case ROW:
7073       case ROWS:
7074       case ROWID:
7075       case ROWNUM:
7076       case ROWTYPE:
7077       case SAVE:
7078       case SAVEPOINT:
7079       case SECOND:
7080       case SELECT:
7081       case SELF:
7082       case SEPARATE:
7083       case SET:
7084       case SHARE:
7085       case SMALLINT:
7086       case SPACE:
7087       case SQL:
7088       case SQLCODE:
7089       case SQLERRM:
7090       case START:
7091       case STATIC:
7092       case STDDEV:
7093       case SUBTYPE:
7094       case SUBSTITUTABLE:
7095       case SUCCESSFUL:
7096       case SUM:
7097       case SYNONYM:
7098       case SYSDATE:
7099       case SYS_REFCURSOR:
7100       case TABLE:
7101       case TEMPORARY:
7102       case THEN:
7103       case TIME:
7104       case TIMESTAMP:
7105       case TIMEZONE_REGION:
7106       case TIMEZONE_ABBR:
7107       case TIMEZONE_MINUTE:
7108       case TIMEZONE_HOUR:
7109       case TO:
7110       case TRANSACTION:
7111       case TRIGGER:
7112       case TRUE:
7113       case TYPE:
7114       case UI:
7115       case UNDER:
7116       case USING:
7117       case WHILE:
7118       case YES:
7119       case SHOW:
7120       case A:
7121       case UPDATE:
7122       case VARCHAR:
7123       case VARCHAR2:
7124       case DOUBLE:
7125       case DEC:
7126       case PRECISION:
7127       case INT:
7128       case NUMERIC:
7129       case SIGNTYPE:
7130       case NCHAR:
7131       case NVARCHAR2:
7132       case STRING:
7133       case UROWID:
7134       case VARRAY:
7135       case VARYING:
7136       case BFILE:
7137       case BLOB:
7138       case CLOB:
7139       case NCLOB:
7140       case YEAR:
7141       case LOCAL:
7142       case WITH:
7143       case ZONE:
7144       case CHARACTER:
7145       case AFTER:
7146       case BEFORE:
7147       case OLD:
7148       case PARENT:
7149       case ANALYZE:
7150       case ASSOCIATE:
7151       case AUDIT:
7152       case COMPOUND:
7153       case DATABASE:
7154       case CALL:
7155       case DDL:
7156       case DISASSOCIATE:
7157       case EACH:
7158       case FOLLOWS:
7159       case LOGOFF:
7160       case LOGON:
7161       case NESTED:
7162       case NOAUDIT:
7163       case SCHEMA:
7164       case SERVERERROR:
7165       case SHUTDOWN:
7166       case STARTUP:
7167       case STATEMENT:
7168       case STATISTICS:
7169       case SUSPEND:
7170       case TRUNCATE:
7171       case WRAPPED:
7172       case LIBRARY:
7173       case NAME:
7174       case STRUCT:
7175       case CONTEXT:
7176       case PARAMETERS:
7177       case LENGTH:
7178       case TDO:
7179       case MAXLEN:
7180       case CHARSETID:
7181       case CHARSETFORM:
7182       case ACCEPT:
7183       case ACCESSIBLE:
7184       case COPY:
7185       case DEFINE:
7186       case DISCONNECT:
7187       case HOST:
7188       case PRINT:
7189       case QUIT:
7190       case REMARK:
7191       case UNDEFINE:
7192       case VARIABLE:
7193       case WHENEVER:
7194       case ATTACH:
7195       case CAST:
7196       case TREAT:
7197       case TRIM:
7198       case LEFT:
7199       case RIGHT:
7200       case BOTH:
7201       case EMPTY:
7202       case MULTISET:
7203       case SUBMULTISET:
7204       case LEADING:
7205       case TRAILING:
7206       case CHAR_CS:
7207       case NCHAR_CS:
7208       case DBTIMEZONE:
7209       case SESSIONTIMEZONE:
7210       case AUTHENTICATED:
7211       case LINK:
7212       case SHARED:
7213       case DIRECTORY:
7214       case USER:
7215       case IDENTIFIER:
7216       case QUOTED_LITERAL:
7217       case SQLDATA_CLASS:
7218       case CUSTOMDATUM_CLASS:
7219       case ORADATA_CLASS:
7220       case JAVA_INTERFACE_CLASS:
7221         simpleNode = FormalParameter();
7222                                          sb.append(simpleNode.getImage());
7223         label_17:
7224         while (true) {
7225           switch (jj_nt.kind) {
7226           case 6:
7227             ;
7228             break;
7229           default:
7230             jj_la1[81] = jj_gen;
7231             break label_17;
7232           }
7233           jj_consume_token(6);
7234           simpleNode = FormalParameter();
7235                                                sb.append(","+simpleNode.getImage());
7236         }
7237         break;
7238       default:
7239         jj_la1[82] = jj_gen;
7240         ;
7241       }
7242       jj_consume_token(7);
7243        sb.append(")");
7244     jjtree.closeNodeScope(jjtn000, true);
7245     jjtc000 = false;
7246     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7247     } catch (Throwable jjte000) {
7248     if (jjtc000) {
7249       jjtree.clearNodeScope(jjtn000);
7250       jjtc000 = false;
7251     } else {
7252       jjtree.popNode();
7253     }
7254     if (jjte000 instanceof RuntimeException) {
7255       {if (true) throw (RuntimeException)jjte000;}
7256     }
7257     if (jjte000 instanceof ParseException) {
7258       {if (true) throw (ParseException)jjte000;}
7259     }
7260     {if (true) throw (Error)jjte000;}
7261     } finally {
7262     if (jjtc000) {
7263       jjtree.closeNodeScope(jjtn000, true);
7264     }
7265     }
7266     throw new Error("Missing return statement in function");
7267   }
7268 
7269   final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270  /*@bgen(jjtree) VariableOrConstantDeclarator */
7271  ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272  boolean jjtc000 = true;
7273  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274  StringBuilder sb = new StringBuilder();
7275     try {
7276       simpleNode = VariableOrConstantDeclaratorId();
7277                                                   sb.append(simpleNode.getImage());
7278       if (jj_2_26(2)) {
7279         jj_consume_token(CONSTANT);
7280                             sb.append(" " + token.image);
7281       } else {
7282         ;
7283       }
7284       simpleNode = Datatype();
7285                                                                                        sb.append(" " + simpleNode.getImage());
7286       switch (jj_nt.kind) {
7287       case NOT:
7288       case NULL:
7289         switch (jj_nt.kind) {
7290         case NOT:
7291           jj_consume_token(NOT);
7292            sb.append(" " + token.image);
7293           break;
7294         default:
7295           jj_la1[83] = jj_gen;
7296           ;
7297         }
7298         jj_consume_token(NULL);
7299                                                     sb.append(" " + token.image);
7300         break;
7301       default:
7302         jj_la1[84] = jj_gen;
7303         ;
7304       }
7305       switch (jj_nt.kind) {
7306       case 9:
7307       case _DEFAULT:
7308         switch (jj_nt.kind) {
7309         case 9:
7310           jj_consume_token(9);
7311           jj_consume_token(10);
7312                sb.append(" :=");
7313           break;
7314         case _DEFAULT:
7315           jj_consume_token(_DEFAULT);
7316                                                sb.append(" " + token.image);
7317           break;
7318         default:
7319           jj_la1[85] = jj_gen;
7320           jj_consume_token(-1);
7321           throw new ParseException();
7322         }
7323         simpleNode = VariableOrConstantInitializer();
7324                                                    sb.append(" " + simpleNode.getImage());
7325         break;
7326       default:
7327         jj_la1[86] = jj_gen;
7328         ;
7329       }
7330     jjtree.closeNodeScope(jjtn000, true);
7331     jjtc000 = false;
7332     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7333     } catch (Throwable jjte000) {
7334     if (jjtc000) {
7335       jjtree.clearNodeScope(jjtn000);
7336       jjtc000 = false;
7337     } else {
7338       jjtree.popNode();
7339     }
7340     if (jjte000 instanceof RuntimeException) {
7341       {if (true) throw (RuntimeException)jjte000;}
7342     }
7343     if (jjte000 instanceof ParseException) {
7344       {if (true) throw (ParseException)jjte000;}
7345     }
7346     {if (true) throw (Error)jjte000;}
7347     } finally {
7348     if (jjtc000) {
7349       jjtree.closeNodeScope(jjtn000, true);
7350     }
7351     }
7352     throw new Error("Missing return statement in function");
7353   }
7354 
7355   final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356  /*@bgen(jjtree) VariableOrConstantDeclaratorId */
7357  ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358  boolean jjtc000 = true;
7359  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360     try {
7361       simpleNode = ID();
7362     jjtree.closeNodeScope(jjtn000, true);
7363     jjtc000 = false;
7364     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7365     } catch (Throwable jjte000) {
7366     if (jjtc000) {
7367       jjtree.clearNodeScope(jjtn000);
7368       jjtc000 = false;
7369     } else {
7370       jjtree.popNode();
7371     }
7372     if (jjte000 instanceof RuntimeException) {
7373       {if (true) throw (RuntimeException)jjte000;}
7374     }
7375     if (jjte000 instanceof ParseException) {
7376       {if (true) throw (ParseException)jjte000;}
7377     }
7378     {if (true) throw (Error)jjte000;}
7379     } finally {
7380     if (jjtc000) {
7381       jjtree.closeNodeScope(jjtn000, true);
7382     }
7383     }
7384     throw new Error("Missing return statement in function");
7385   }
7386 
7387   final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388  /*@bgen(jjtree) VariableOrConstantInitializer */
7389  ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390  boolean jjtc000 = true;
7391  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392     try {
7393       simpleNode = Expression();
7394     jjtree.closeNodeScope(jjtn000, true);
7395     jjtc000 = false;
7396     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7397     } catch (Throwable jjte000) {
7398    if (jjtc000) {
7399      jjtree.clearNodeScope(jjtn000);
7400      jjtc000 = false;
7401    } else {
7402      jjtree.popNode();
7403    }
7404    if (jjte000 instanceof RuntimeException) {
7405      {if (true) throw (RuntimeException)jjte000;}
7406    }
7407    if (jjte000 instanceof ParseException) {
7408      {if (true) throw (ParseException)jjte000;}
7409    }
7410    {if (true) throw (Error)jjte000;}
7411     } finally {
7412    if (jjtc000) {
7413      jjtree.closeNodeScope(jjtn000, true);
7414    }
7415     }
7416     throw new Error("Missing return statement in function");
7417   }
7418 
7419   final public ASTDatatype Datatype() throws ParseException {
7420  /*@bgen(jjtree) Datatype */
7421  ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422  boolean jjtc000 = true;
7423  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424  StringBuilder sb = new StringBuilder();
7425     try {
7426       switch (jj_nt.kind) {
7427       case CC_IF:
7428         // this should be first
7429                         simpleNode = CompilationDataType();
7430                                                     sb.append(simpleNode.getImage());
7431         break;
7432       default:
7433         jj_la1[90] = jj_gen;
7434         if (jj_2_28(2)) {
7435           simpleNode = ScalarDataTypeName();
7436                                                                 sb.append(simpleNode.getImage());
7437         } else {
7438           switch (jj_nt.kind) {
7439           case REPLACE:
7440           case DEFINER:
7441           case CURRENT_USER:
7442           case LANGUAGE:
7443           case INLINE:
7444           case ADD:
7445           case AGGREGATE:
7446           case ARRAY:
7447           case AT:
7448           case ATTRIBUTE:
7449           case AUTHID:
7450           case BODY:
7451           case BULK:
7452           case BYTE:
7453           case CASCADE:
7454           case CLOSE:
7455           case COALESCE:
7456           case COLLECT:
7457           case COLUMN:
7458           case COMMENT:
7459           case COMMIT:
7460           case CONSTRUCTOR:
7461           case CONTINUE:
7462           case CONVERT:
7463           case CURRENT:
7464           case CURSOR:
7465           case DATA:
7466           case DAY:
7467           case DISABLE:
7468           case EDITIONABLE:
7469           case ELEMENT:
7470           case ENABLE:
7471           case ESCAPE:
7472           case EXCEPT:
7473           case EXCEPTIONS:
7474           case EXIT:
7475           case EXTERNAL:
7476           case EXTENDS:
7477           case EXTRACT:
7478           case FALSE:
7479           case FINAL:
7480           case FORCE:
7481           case FUNCTION:
7482           case GLOBAL:
7483           case HASH:
7484           case HEAP:
7485           case HOUR:
7486           case IMMEDIATE:
7487           case INDICES:
7488           case INDEXTYPE:
7489           case INDICATOR:
7490           case INSTANTIABLE:
7491           case INTERVAL:
7492           case INVALIDATE:
7493           case ISOLATION:
7494           case JAVA:
7495           case LEVEL:
7496           case LIMIT:
7497           case LOOP:
7498           case MAP:
7499           case MAX:
7500           case MEMBER:
7501           case MERGE:
7502           case MIN:
7503           case MINUTE:
7504           case MLSLABEL:
7505           case MODIFY:
7506           case MOD:
7507           case MONTH:
7508           case NATURAL:
7509           case NEW:
7510           case NO:
7511           case NONEDITIONABLE:
7512           case NULLIF:
7513           case OBJECT:
7514           case OID:
7515           case OPAQUE:
7516           case OPEN:
7517           case OPERATOR:
7518           case ORGANIZATION:
7519           case OTHERS:
7520           case OVERRIDING:
7521           case PACKAGE:
7522           case PARTITION:
7523           case PRESERVE:
7524           case PRIVATE:
7525           case PROCEDURE:
7526           case RANGE:
7527           case RAW:
7528           case REAL:
7529           case RECORD:
7530           case REF:
7531           case RELEASE:
7532           case RELIES_ON:
7533           case RENAME:
7534           case RESULT:
7535           case RETURN:
7536           case RETURNING:
7537           case REVERSE:
7538           case ROLLBACK:
7539           case ROW:
7540           case ROWS:
7541           case ROWID:
7542           case ROWNUM:
7543           case SAVE:
7544           case SAVEPOINT:
7545           case SECOND:
7546           case SELF:
7547           case SET:
7548           case SPACE:
7549           case SQL:
7550           case SQLCODE:
7551           case SQLERRM:
7552           case STATIC:
7553           case SUBTYPE:
7554           case SUBSTITUTABLE:
7555           case SUCCESSFUL:
7556           case SYSDATE:
7557           case SYS_REFCURSOR:
7558           case TEMPORARY:
7559           case TIME:
7560           case TIMESTAMP:
7561           case TIMEZONE_REGION:
7562           case TIMEZONE_ABBR:
7563           case TIMEZONE_MINUTE:
7564           case TIMEZONE_HOUR:
7565           case TRANSACTION:
7566           case TRUE:
7567           case TYPE:
7568           case UNDER:
7569           case USING:
7570           case YES:
7571           case SHOW:
7572           case A:
7573           case DOUBLE:
7574           case DEC:
7575           case PRECISION:
7576           case INT:
7577           case NUMERIC:
7578           case NCHAR:
7579           case NVARCHAR2:
7580           case STRING:
7581           case UROWID:
7582           case VARRAY:
7583           case VARYING:
7584           case BFILE:
7585           case BLOB:
7586           case CLOB:
7587           case NCLOB:
7588           case YEAR:
7589           case LOCAL:
7590           case ZONE:
7591           case CHARACTER:
7592           case AFTER:
7593           case BEFORE:
7594           case OLD:
7595           case PARENT:
7596           case ANALYZE:
7597           case ASSOCIATE:
7598           case AUDIT:
7599           case COMPOUND:
7600           case DATABASE:
7601           case CALL:
7602           case DDL:
7603           case DISASSOCIATE:
7604           case EACH:
7605           case FOLLOWS:
7606           case LOGOFF:
7607           case LOGON:
7608           case NESTED:
7609           case NOAUDIT:
7610           case SCHEMA:
7611           case SERVERERROR:
7612           case SHUTDOWN:
7613           case STARTUP:
7614           case STATEMENT:
7615           case STATISTICS:
7616           case SUSPEND:
7617           case TRUNCATE:
7618           case WRAPPED:
7619           case LIBRARY:
7620           case NAME:
7621           case STRUCT:
7622           case CONTEXT:
7623           case PARAMETERS:
7624           case LENGTH:
7625           case TDO:
7626           case MAXLEN:
7627           case CHARSETID:
7628           case CHARSETFORM:
7629           case ACCEPT:
7630           case ACCESSIBLE:
7631           case COPY:
7632           case DEFINE:
7633           case DISCONNECT:
7634           case HOST:
7635           case PRINT:
7636           case QUIT:
7637           case REMARK:
7638           case UNDEFINE:
7639           case VARIABLE:
7640           case WHENEVER:
7641           case ATTACH:
7642           case CAST:
7643           case TREAT:
7644           case TRIM:
7645           case LEFT:
7646           case RIGHT:
7647           case BOTH:
7648           case EMPTY:
7649           case MULTISET:
7650           case SUBMULTISET:
7651           case LEADING:
7652           case TRAILING:
7653           case CHAR_CS:
7654           case NCHAR_CS:
7655           case DBTIMEZONE:
7656           case SESSIONTIMEZONE:
7657           case AUTHENTICATED:
7658           case LINK:
7659           case SHARED:
7660           case DIRECTORY:
7661           case USER:
7662           case IDENTIFIER:
7663           case QUOTED_LITERAL:
7664             if (jj_2_27(2)) {
7665               jj_consume_token(REF);
7666                                           sb.append(token.image);
7667             } else {
7668               ;
7669             }
7670             simpleNode = QualifiedName();
7671                                                                                                     sb.append(simpleNode.getImage());
7672             switch (jj_nt.kind) {
7673             case 2:
7674               jj_consume_token(2);
7675               simpleNode = QualifiedName();
7676                                                        sb.append("@"+simpleNode.getImage());
7677               break;
7678             default:
7679               jj_la1[87] = jj_gen;
7680               ;
7681             }
7682             switch (jj_nt.kind) {
7683             case 11:
7684               jj_consume_token(11);
7685               switch (jj_nt.kind) {
7686               case TYPE:
7687                 jj_consume_token(TYPE);
7688                 break;
7689               case ROWTYPE:
7690                 jj_consume_token(ROWTYPE);
7691                 break;
7692               default:
7693                 jj_la1[88] = jj_gen;
7694                 jj_consume_token(-1);
7695                 throw new ParseException();
7696               }
7697                                             sb.append("%"+token.image);
7698               break;
7699             default:
7700               jj_la1[89] = jj_gen;
7701               ;
7702             }
7703             break;
7704           default:
7705             jj_la1[91] = jj_gen;
7706             jj_consume_token(-1);
7707             throw new ParseException();
7708           }
7709         }
7710       }
7711           jjtree.closeNodeScope(jjtn000, true);
7712           jjtc000 = false;
7713           jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7714     } catch (Throwable jjte000) {
7715           if (jjtc000) {
7716             jjtree.clearNodeScope(jjtn000);
7717             jjtc000 = false;
7718           } else {
7719             jjtree.popNode();
7720           }
7721           if (jjte000 instanceof RuntimeException) {
7722             {if (true) throw (RuntimeException)jjte000;}
7723           }
7724           if (jjte000 instanceof ParseException) {
7725             {if (true) throw (ParseException)jjte000;}
7726           }
7727           {if (true) throw (Error)jjte000;}
7728     } finally {
7729           if (jjtc000) {
7730             jjtree.closeNodeScope(jjtn000, true);
7731           }
7732     }
7733     throw new Error("Missing return statement in function");
7734   }
7735 
7736   final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737  /*@bgen(jjtree) CompilationDataType */
7738   ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739   boolean jjtc000 = true;
7740   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741   StringBuilder sb = new StringBuilder() ;
7742     try {
7743       jj_consume_token(CC_IF);
7744                    sb.append(" "); sb.append(token.image) ;
7745       simpleNode = ConditionalOrExpression();
7746                                                  sb.append(" "); sb.append(simpleNode.getImage());
7747       jj_consume_token(CC_THEN);
7748                      sb.append(" "); sb.append(token.image);
7749       simpleNode = Datatype();
7750                                    sb.append(" "); sb.append(simpleNode.getImage());
7751       label_18:
7752       while (true) {
7753         switch (jj_nt.kind) {
7754         case CC_ELSIF:
7755           ;
7756           break;
7757         default:
7758           jj_la1[92] = jj_gen;
7759           break label_18;
7760         }
7761         jj_consume_token(CC_ELSIF);
7762                         sb.append(" "); sb.append(token.image);
7763         simpleNode = ConditionalOrExpression();
7764                                                     sb.append(" "); sb.append(simpleNode.getImage());
7765         jj_consume_token(CC_THEN);
7766                        sb.append(" "); sb.append(token.image);
7767         simpleNode = Datatype();
7768                                      sb.append(" "); sb.append(simpleNode.getImage());
7769       }
7770       label_19:
7771       while (true) {
7772         switch (jj_nt.kind) {
7773         case CC_ELSE:
7774           ;
7775           break;
7776         default:
7777           jj_la1[93] = jj_gen;
7778           break label_19;
7779         }
7780         jj_consume_token(CC_ELSE);
7781                        sb.append(" "); sb.append(token.image);
7782         simpleNode = Datatype();
7783                                       sb.append(" "); sb.append(simpleNode.getImage());
7784       }
7785       jj_consume_token(CC_END);
7786                     sb.append(" "); sb.append(token.image);
7787    jjtree.closeNodeScope(jjtn000, true);
7788    jjtc000 = false;
7789  jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7790     } catch (Throwable jjte000) {
7791           if (jjtc000) {
7792             jjtree.clearNodeScope(jjtn000);
7793             jjtc000 = false;
7794           } else {
7795             jjtree.popNode();
7796           }
7797           if (jjte000 instanceof RuntimeException) {
7798             {if (true) throw (RuntimeException)jjte000;}
7799           }
7800           if (jjte000 instanceof ParseException) {
7801             {if (true) throw (ParseException)jjte000;}
7802           }
7803           {if (true) throw (Error)jjte000;}
7804     } finally {
7805           if (jjtc000) {
7806             jjtree.closeNodeScope(jjtn000, true);
7807           }
7808     }
7809     throw new Error("Missing return statement in function");
7810   }
7811 
7812   final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813  /*@bgen(jjtree) CollectionTypeName */
7814   ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815   boolean jjtc000 = true;
7816   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817         StringBuilder sb = new StringBuilder();
7818     try {
7819       switch (jj_nt.kind) {
7820       case TABLE:
7821         jj_consume_token(TABLE);
7822         break;
7823       case VARRAY:
7824         jj_consume_token(VARRAY);
7825         break;
7826       case VARYING:
7827         jj_consume_token(VARYING);
7828         jj_consume_token(ARRAY);
7829                                                 sb.append( "VARYING ARRAY") ;
7830         break;
7831       default:
7832         jj_la1[94] = jj_gen;
7833         jj_consume_token(-1);
7834         throw new ParseException();
7835       }
7836       if (sb.length() ==  0) {
7837         sb.append(token.toString());
7838       }
7839       if (jj_2_29(2)) {
7840         jj_consume_token(5);
7841         size = NumericLiteral();
7842                                                  sb.append( "(" + size);
7843         switch (jj_nt.kind) {
7844         case 6:
7845           jj_consume_token(6);
7846           precision = NumericLiteral();
7847                                                  sb.append( "," + precision);
7848           break;
7849         default:
7850           jj_la1[95] = jj_gen;
7851           ;
7852         }
7853         switch (jj_nt.kind) {
7854         case CHAR:
7855           jj_consume_token(CHAR);
7856                           sb.append( " CHAR") ;
7857           break;
7858         default:
7859           jj_la1[96] = jj_gen;
7860           ;
7861         }
7862         switch (jj_nt.kind) {
7863         case BYTE:
7864           jj_consume_token(BYTE);
7865                           sb.append( " BYTE") ;
7866           break;
7867         default:
7868           jj_la1[97] = jj_gen;
7869           ;
7870         }
7871         jj_consume_token(7);
7872              sb.append( ")");
7873       } else {
7874         ;
7875       }
7876         jjtree.closeNodeScope(jjtn000, true);
7877         jjtc000 = false;
7878         jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7879     } catch (Throwable jjte000) {
7880        if (jjtc000) {
7881          jjtree.clearNodeScope(jjtn000);
7882          jjtc000 = false;
7883        } else {
7884          jjtree.popNode();
7885        }
7886        if (jjte000 instanceof RuntimeException) {
7887          {if (true) throw (RuntimeException)jjte000;}
7888        }
7889        if (jjte000 instanceof ParseException) {
7890          {if (true) throw (ParseException)jjte000;}
7891        }
7892        {if (true) throw (Error)jjte000;}
7893     } finally {
7894        if (jjtc000) {
7895          jjtree.closeNodeScope(jjtn000, true);
7896        }
7897     }
7898     throw new Error("Missing return statement in function");
7899   }
7900 
7901   final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902  /*@bgen(jjtree) ScalarDataTypeName */
7903   ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904   boolean jjtc000 = true;
7905   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906         StringBuilder name = new StringBuilder();
7907         PLSQLNode characterSet = null;
7908     try {
7909       switch (jj_nt.kind) {
7910       case BFILE_BASE:
7911         jj_consume_token(BFILE_BASE);
7912         break;
7913       case BLOB_BASE:
7914         jj_consume_token(BLOB_BASE);
7915         break;
7916       case CHAR_BASE:
7917         jj_consume_token(CHAR_BASE);
7918         break;
7919       case CLOB_BASE:
7920         jj_consume_token(CLOB_BASE);
7921         break;
7922       case DATE_BASE:
7923         jj_consume_token(DATE_BASE);
7924         break;
7925       case NUMBER_BASE:
7926         jj_consume_token(NUMBER_BASE);
7927         break;
7928       case BINARY_INTEGER:
7929         jj_consume_token(BINARY_INTEGER);
7930         break;
7931       case DEC:
7932         jj_consume_token(DEC);
7933         break;
7934       case DECIMAL:
7935         jj_consume_token(DECIMAL);
7936         break;
7937       case DOUBLE:
7938         jj_consume_token(DOUBLE);
7939         jj_consume_token(PRECISION);
7940                                                                      name.append("DOUBLE PRECISION");
7941         break;
7942       case FLOAT:
7943         jj_consume_token(FLOAT);
7944         break;
7945       case INT:
7946         jj_consume_token(INT);
7947         break;
7948       case INTEGER:
7949         jj_consume_token(INTEGER);
7950         break;
7951       case NATURAL:
7952         jj_consume_token(NATURAL);
7953         break;
7954       case NATURALN:
7955         jj_consume_token(NATURALN);
7956         break;
7957       case NUMBER:
7958         jj_consume_token(NUMBER);
7959         break;
7960       case NUMERIC:
7961         jj_consume_token(NUMERIC);
7962         break;
7963       case PLS_INTEGER:
7964         jj_consume_token(PLS_INTEGER);
7965         break;
7966       case POSITIVE:
7967         jj_consume_token(POSITIVE);
7968         break;
7969       case POSITIVEN:
7970         jj_consume_token(POSITIVEN);
7971         break;
7972       case REAL:
7973         jj_consume_token(REAL);
7974         break;
7975       case SIGNTYPE:
7976         jj_consume_token(SIGNTYPE);
7977         break;
7978       case SMALLINT:
7979         jj_consume_token(SMALLINT);
7980         break;
7981       case CHAR:
7982       case LONG:
7983       case RAW:
7984       case ROWID:
7985       case VARCHAR:
7986       case VARCHAR2:
7987       case NCHAR:
7988       case NVARCHAR2:
7989       case STRING:
7990       case UROWID:
7991       case CLOB:
7992       case NCLOB:
7993       case CHARACTER:
7994         switch (jj_nt.kind) {
7995         case CHAR:
7996           jj_consume_token(CHAR);
7997           break;
7998         case CHARACTER:
7999           jj_consume_token(CHARACTER);
8000           break;
8001         default:
8002           jj_la1[98] = jj_gen;
8003           if (jj_2_30(2)) {
8004             jj_consume_token(LONG);
8005             jj_consume_token(RAW);
8006                                        name.append("LONG RAW");
8007           } else {
8008             switch (jj_nt.kind) {
8009             case LONG:
8010               jj_consume_token(LONG);
8011               break;
8012             case NCHAR:
8013               jj_consume_token(NCHAR);
8014               break;
8015             case NVARCHAR2:
8016               jj_consume_token(NVARCHAR2);
8017               break;
8018             case RAW:
8019               jj_consume_token(RAW);
8020               break;
8021             case ROWID:
8022               jj_consume_token(ROWID);
8023               break;
8024             case STRING:
8025               jj_consume_token(STRING);
8026               break;
8027             case UROWID:
8028               jj_consume_token(UROWID);
8029               break;
8030             case VARCHAR:
8031               jj_consume_token(VARCHAR);
8032               break;
8033             case VARCHAR2:
8034               jj_consume_token(VARCHAR2);
8035               break;
8036             case CLOB:
8037               jj_consume_token(CLOB);
8038               break;
8039             case NCLOB:
8040               jj_consume_token(NCLOB);
8041               break;
8042             default:
8043               jj_la1[99] = jj_gen;
8044               jj_consume_token(-1);
8045               throw new ParseException();
8046             }
8047           }
8048         }
8049         break;
8050       case BOOLEAN:
8051         jj_consume_token(BOOLEAN);
8052         break;
8053       case BFILE:
8054         jj_consume_token(BFILE);
8055         break;
8056       case BLOB:
8057         jj_consume_token(BLOB);
8058         break;
8059       case SYS_REFCURSOR:
8060         jj_consume_token(SYS_REFCURSOR);
8061         break;
8062       case REF:
8063         jj_consume_token(REF);
8064         jj_consume_token(CURSOR);
8065                         name.append("REF CURSOR");
8066         break;
8067       case DATE:
8068         jj_consume_token(DATE);
8069         break;
8070       default:
8071         jj_la1[100] = jj_gen;
8072         if (jj_2_31(2)) {
8073           jj_consume_token(INTERVAL);
8074           jj_consume_token(YEAR);
8075                                         name.append("INTERVAL YEAR");
8076         } else if (jj_2_32(2)) {
8077           jj_consume_token(INTERVAL);
8078           jj_consume_token(DAY);
8079                                        name.append("INTERVAL DAY");
8080         } else {
8081           switch (jj_nt.kind) {
8082           case TIME:
8083             jj_consume_token(TIME);
8084             break;
8085           case TIMESTAMP:
8086             jj_consume_token(TIMESTAMP);
8087             break;
8088           case SELF:
8089             jj_consume_token(SELF);
8090             jj_consume_token(AS);
8091             jj_consume_token(RESULT);
8092                              name.append("SELF AS RESULT");
8093             break;
8094           default:
8095             jj_la1[101] = jj_gen;
8096             jj_consume_token(-1);
8097             throw new ParseException();
8098           }
8099         }
8100       }
8101       if (name.length() == 0 ) {
8102         name.append(token.toString());
8103       }
8104       if (jj_2_33(2)) {
8105         jj_consume_token(5);
8106         size = NumericLiteral();
8107                                                  name.append("("); name.append(size.getImage()) ;
8108         switch (jj_nt.kind) {
8109         case 6:
8110           jj_consume_token(6);
8111           precision = UnaryExpression(true);
8112                                                       name.append(",") ; name.append(precision.getImage()) ;
8113           break;
8114         default:
8115           jj_la1[102] = jj_gen;
8116           ;
8117         }
8118         switch (jj_nt.kind) {
8119         case CHAR:
8120           jj_consume_token(CHAR);
8121                           name.append(" CHAR") ;
8122           break;
8123         default:
8124           jj_la1[103] = jj_gen;
8125           ;
8126         }
8127         switch (jj_nt.kind) {
8128         case BYTE:
8129           jj_consume_token(BYTE);
8130                           name.append(" BYTE") ;
8131           break;
8132         default:
8133           jj_la1[104] = jj_gen;
8134           ;
8135         }
8136         jj_consume_token(7);
8137              name.append( ")") ;
8138       } else {
8139         ;
8140       }
8141       switch (jj_nt.kind) {
8142       case TO:
8143       case WITH:
8144       case CHARACTER:
8145         switch (jj_nt.kind) {
8146         case CHARACTER:
8147           jj_consume_token(CHARACTER);
8148           jj_consume_token(SET);
8149           characterSet = Name();
8150                                               name.append( " CHARACTER SET ") ;  name.append(characterSet.getImage()) ;
8151           break;
8152         default:
8153           jj_la1[105] = jj_gen;
8154           if (jj_2_35(4)) {
8155             jj_consume_token(WITH);
8156             jj_consume_token(LOCAL);
8157             jj_consume_token(TIME);
8158             jj_consume_token(ZONE);
8159                                              name.append(" WITH LOCAL TIME ZONE");
8160           } else if (jj_2_36(3)) {
8161             jj_consume_token(WITH);
8162             jj_consume_token(TIME);
8163             jj_consume_token(ZONE);
8164                                       name.append( " WITH TIME ZONE");
8165           } else if (jj_2_37(2)) {
8166             jj_consume_token(TO);
8167             jj_consume_token(MONTH);
8168                                name.append( " TO MONTH");
8169           } else if (jj_2_38(2)) {
8170             jj_consume_token(TO);
8171             jj_consume_token(SECOND);
8172                                 name.append( " TO SECOND");
8173             if (jj_2_34(2)) {
8174               jj_consume_token(5);
8175               precision = NumericLiteral();
8176                                                                        name.append( "(" + precision) ;
8177               jj_consume_token(7);
8178                                              name.append( ")");
8179             } else {
8180               ;
8181             }
8182           } else {
8183             jj_consume_token(-1);
8184             throw new ParseException();
8185           }
8186         }
8187         break;
8188       default:
8189         jj_la1[106] = jj_gen;
8190         ;
8191       }
8192         jjtree.closeNodeScope(jjtn000, true);
8193         jjtc000 = false;
8194         jjtn000.setImage(name.toString()) ;  {if (true) return jjtn000;}
8195     } catch (Throwable jjte000) {
8196           if (jjtc000) {
8197             jjtree.clearNodeScope(jjtn000);
8198             jjtc000 = false;
8199           } else {
8200             jjtree.popNode();
8201           }
8202           if (jjte000 instanceof RuntimeException) {
8203             {if (true) throw (RuntimeException)jjte000;}
8204           }
8205           if (jjte000 instanceof ParseException) {
8206             {if (true) throw (ParseException)jjte000;}
8207           }
8208           {if (true) throw (Error)jjte000;}
8209     } finally {
8210           if (jjtc000) {
8211             jjtree.closeNodeScope(jjtn000, true);
8212           }
8213     }
8214     throw new Error("Missing return statement in function");
8215   }
8216 
8217   final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218  /*@bgen(jjtree) DateTimeLiteral */
8219  ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220  boolean jjtc000 = true;
8221  jjtree.openNodeScope(jjtn000);Token t = null ;
8222  PLSQLNode simpleNode = null ;
8223  StringBuilder sb = new StringBuilder() ;
8224     try {
8225       switch (jj_nt.kind) {
8226       case INTERVAL:
8227         jj_consume_token(INTERVAL);
8228         break;
8229       case TIMESTAMP:
8230         jj_consume_token(TIMESTAMP);
8231         break;
8232       case DATE:
8233         jj_consume_token(DATE);
8234         break;
8235       default:
8236         jj_la1[107] = jj_gen;
8237         jj_consume_token(-1);
8238         throw new ParseException();
8239       }
8240           sb.append(token.image);
8241       switch (jj_nt.kind) {
8242       case CHARACTER_LITERAL:
8243         jj_consume_token(CHARACTER_LITERAL);
8244                                 sb.append(" ");  sb.append(token.image);
8245         break;
8246       case STRING_LITERAL:
8247         simpleNode = StringLiteral();
8248                                         sb.append(" ");  sb.append(simpleNode.getImage());
8249         break;
8250       default:
8251         jj_la1[108] = jj_gen;
8252         jj_consume_token(-1);
8253         throw new ParseException();
8254       }
8255       switch (jj_nt.kind) {
8256       case DAY:
8257       case HOUR:
8258       case MINUTE:
8259       case MONTH:
8260       case SECOND:
8261       case YEAR:
8262         switch (jj_nt.kind) {
8263         case YEAR:
8264           jj_consume_token(YEAR);
8265           break;
8266         case MONTH:
8267           jj_consume_token(MONTH);
8268           break;
8269         case DAY:
8270           jj_consume_token(DAY);
8271           break;
8272         case HOUR:
8273           jj_consume_token(HOUR);
8274           break;
8275         case MINUTE:
8276           jj_consume_token(MINUTE);
8277           break;
8278         case SECOND:
8279           jj_consume_token(SECOND);
8280           break;
8281         default:
8282           jj_la1[109] = jj_gen;
8283           jj_consume_token(-1);
8284           throw new ParseException();
8285         }
8286         break;
8287       default:
8288         jj_la1[110] = jj_gen;
8289         ;
8290       }
8291            if (null != t)
8292            {
8293             sb.append(" ");  sb.append(token.image);
8294             t = null;
8295            }
8296       if (jj_2_39(2)) {
8297         jj_consume_token(5);
8298         simpleNode = NumericLiteral();
8299                                                            sb.append("(");  sb.append(simpleNode.getImage());
8300         jj_consume_token(7);
8301                sb.append("}");
8302       } else {
8303         ;
8304       }
8305       switch (jj_nt.kind) {
8306       case TO:
8307       case WITH:
8308         switch (jj_nt.kind) {
8309         case WITH:
8310           jj_consume_token(WITH);
8311               sb.append(" "); sb.append(token.toString()) ;
8312           switch (jj_nt.kind) {
8313           case LOCAL:
8314             jj_consume_token(LOCAL);
8315                   sb.append(" "); sb.append(token.toString()) ;
8316             break;
8317           default:
8318             jj_la1[111] = jj_gen;
8319             ;
8320           }
8321           jj_consume_token(TIME);
8322           jj_consume_token(ZONE);
8323                     sb.append(" "); sb.append("TIME ZONE") ;
8324           break;
8325         case TO:
8326           jj_consume_token(TO);
8327             sb.append(" "); sb.append(token.toString()) ;
8328           switch (jj_nt.kind) {
8329           case YEAR:
8330             jj_consume_token(YEAR);
8331             break;
8332           case MONTH:
8333             jj_consume_token(MONTH);
8334             break;
8335           case DAY:
8336             jj_consume_token(DAY);
8337             break;
8338           case HOUR:
8339             jj_consume_token(HOUR);
8340             break;
8341           case MINUTE:
8342             jj_consume_token(MINUTE);
8343             break;
8344           case SECOND:
8345             jj_consume_token(SECOND);
8346             break;
8347           default:
8348             jj_la1[112] = jj_gen;
8349             jj_consume_token(-1);
8350             throw new ParseException();
8351           }
8352           sb.append(token.image);
8353           if (jj_2_40(2)) {
8354             jj_consume_token(5);
8355             simpleNode = NumericLiteral();
8356                                                            sb.append("(");  sb.append(simpleNode.getImage());
8357             jj_consume_token(7);
8358                 sb.append("}");
8359           } else {
8360             ;
8361           }
8362           break;
8363         default:
8364           jj_la1[113] = jj_gen;
8365           jj_consume_token(-1);
8366           throw new ParseException();
8367         }
8368         break;
8369       default:
8370         jj_la1[114] = jj_gen;
8371         ;
8372       }
8373      jjtree.closeNodeScope(jjtn000, true);
8374      jjtc000 = false;
8375     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
8376     } catch (Throwable jjte000) {
8377       if (jjtc000) {
8378         jjtree.clearNodeScope(jjtn000);
8379         jjtc000 = false;
8380       } else {
8381         jjtree.popNode();
8382       }
8383       if (jjte000 instanceof RuntimeException) {
8384         {if (true) throw (RuntimeException)jjte000;}
8385       }
8386       if (jjte000 instanceof ParseException) {
8387         {if (true) throw (ParseException)jjte000;}
8388       }
8389       {if (true) throw (Error)jjte000;}
8390     } finally {
8391       if (jjtc000) {
8392         jjtree.closeNodeScope(jjtn000, true);
8393       }
8394     }
8395     throw new Error("Missing return statement in function");
8396   }
8397 
8398   final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399  /*@bgen(jjtree) ExceptionHandler */
8400   ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401   boolean jjtc000 = true;
8402   jjtree.openNodeScope(jjtn000);
8403     try {
8404       jj_consume_token(EXCEPTION);
8405       label_20:
8406       while (true) {
8407         if (jj_2_41(2)) {
8408           ;
8409         } else {
8410           break label_20;
8411         }
8412         jj_consume_token(WHEN);
8413         QualifiedName();
8414         label_21:
8415         while (true) {
8416           switch (jj_nt.kind) {
8417           case OR:
8418             ;
8419             break;
8420           default:
8421             jj_la1[115] = jj_gen;
8422             break label_21;
8423           }
8424           jj_consume_token(OR);
8425           QualifiedName();
8426         }
8427         jj_consume_token(THEN);
8428         label_22:
8429         while (true) {
8430           Statement();
8431           switch (jj_nt.kind) {
8432           case 5:
8433           case 16:
8434           case 17:
8435           case 21:
8436           case REPLACE:
8437           case DEFINER:
8438           case CURRENT_USER:
8439           case LANGUAGE:
8440           case INLINE:
8441           case ADD:
8442           case AGGREGATE:
8443           case ARRAY:
8444           case AT:
8445           case ATTRIBUTE:
8446           case AUTHID:
8447           case BEGIN:
8448           case BODY:
8449           case BULK:
8450           case BYTE:
8451           case CASCADE:
8452           case CASE:
8453           case CLOSE:
8454           case COALESCE:
8455           case COLLECT:
8456           case COLUMN:
8457           case COMMENT:
8458           case COMMIT:
8459           case CONSTRUCTOR:
8460           case CONTINUE:
8461           case CONVERT:
8462           case CURRENT:
8463           case CURSOR:
8464           case DATA:
8465           case DATE:
8466           case DAY:
8467           case DECLARE:
8468           case DELETE:
8469           case DISABLE:
8470           case EDITIONABLE:
8471           case ELEMENT:
8472           case ENABLE:
8473           case ESCAPE:
8474           case EXCEPT:
8475           case EXCEPTIONS:
8476           case EXECUTE:
8477           case EXIT:
8478           case EXTERNAL:
8479           case EXTENDS:
8480           case EXTRACT:
8481           case FALSE:
8482           case FETCH:
8483           case FINAL:
8484           case FOR:
8485           case FORALL:
8486           case FORCE:
8487           case FUNCTION:
8488           case GLOBAL:
8489           case GOTO:
8490           case HASH:
8491           case HEAP:
8492           case HOUR:
8493           case IF:
8494           case IMMEDIATE:
8495           case INDICES:
8496           case INDEXTYPE:
8497           case INDICATOR:
8498           case INSERT:
8499           case INSTANTIABLE:
8500           case INTERVAL:
8501           case INVALIDATE:
8502           case ISOLATION:
8503           case JAVA:
8504           case LEVEL:
8505           case LIMIT:
8506           case LOCK:
8507           case LOOP:
8508           case MAP:
8509           case MAX:
8510           case MEMBER:
8511           case MERGE:
8512           case MIN:
8513           case MINUTE:
8514           case MLSLABEL:
8515           case MODIFY:
8516           case MOD:
8517           case MONTH:
8518           case NATURAL:
8519           case NEW:
8520           case NEW_DOT:
8521           case NO:
8522           case NONEDITIONABLE:
8523           case NOT:
8524           case NULL:
8525           case NULLIF:
8526           case OBJECT:
8527           case OID:
8528           case OPAQUE:
8529           case OPEN:
8530           case OPERATOR:
8531           case ORGANIZATION:
8532           case OTHERS:
8533           case OVERRIDING:
8534           case PACKAGE:
8535           case PARTITION:
8536           case PIPE:
8537           case PRAGMA:
8538           case PRESERVE:
8539           case PRIVATE:
8540           case PROCEDURE:
8541           case RAISE:
8542           case RANGE:
8543           case RAW:
8544           case REAL:
8545           case RECORD:
8546           case REF:
8547           case RELEASE:
8548           case RELIES_ON:
8549           case RENAME:
8550           case RESULT:
8551           case RETURN:
8552           case RETURNING:
8553           case REVERSE:
8554           case ROLLBACK:
8555           case ROW:
8556           case ROWS:
8557           case ROWID:
8558           case ROWNUM:
8559           case SAVE:
8560           case SAVEPOINT:
8561           case SECOND:
8562           case SELECT:
8563           case SELF:
8564           case SET:
8565           case SPACE:
8566           case SQL:
8567           case SQLCODE:
8568           case SQLERRM:
8569           case STATIC:
8570           case SUBTYPE:
8571           case SUBSTITUTABLE:
8572           case SUCCESSFUL:
8573           case SYSDATE:
8574           case SYS_REFCURSOR:
8575           case TEMPORARY:
8576           case TIME:
8577           case TIMESTAMP:
8578           case TIMEZONE_REGION:
8579           case TIMEZONE_ABBR:
8580           case TIMEZONE_MINUTE:
8581           case TIMEZONE_HOUR:
8582           case TRANSACTION:
8583           case TRUE:
8584           case TYPE:
8585           case UNDER:
8586           case USING:
8587           case WHILE:
8588           case YES:
8589           case SHOW:
8590           case A:
8591           case UPDATE:
8592           case DOUBLE:
8593           case DEC:
8594           case PRECISION:
8595           case INT:
8596           case NUMERIC:
8597           case NCHAR:
8598           case NVARCHAR2:
8599           case STRING:
8600           case UROWID:
8601           case VARRAY:
8602           case VARYING:
8603           case BFILE:
8604           case BLOB:
8605           case CLOB:
8606           case NCLOB:
8607           case YEAR:
8608           case LOCAL:
8609           case WITH:
8610           case ZONE:
8611           case CHARACTER:
8612           case AFTER:
8613           case BEFORE:
8614           case OLD:
8615           case PARENT:
8616           case CC_IF:
8617           case CC_ERROR:
8618           case ANALYZE:
8619           case ASSOCIATE:
8620           case AUDIT:
8621           case COMPOUND:
8622           case DATABASE:
8623           case CALL:
8624           case DDL:
8625           case DISASSOCIATE:
8626           case EACH:
8627           case FOLLOWS:
8628           case LOGOFF:
8629           case LOGON:
8630           case NESTED:
8631           case NOAUDIT:
8632           case SCHEMA:
8633           case SERVERERROR:
8634           case SHUTDOWN:
8635           case STARTUP:
8636           case STATEMENT:
8637           case STATISTICS:
8638           case SUSPEND:
8639           case TRUNCATE:
8640           case WRAPPED:
8641           case LIBRARY:
8642           case NAME:
8643           case STRUCT:
8644           case CONTEXT:
8645           case PARAMETERS:
8646           case LENGTH:
8647           case TDO:
8648           case MAXLEN:
8649           case CHARSETID:
8650           case CHARSETFORM:
8651           case ACCEPT:
8652           case ACCESSIBLE:
8653           case COPY:
8654           case DEFINE:
8655           case DISCONNECT:
8656           case HOST:
8657           case PRINT:
8658           case QUIT:
8659           case REMARK:
8660           case UNDEFINE:
8661           case VARIABLE:
8662           case WHENEVER:
8663           case ATTACH:
8664           case CAST:
8665           case TREAT:
8666           case TRIM:
8667           case LEFT:
8668           case RIGHT:
8669           case BOTH:
8670           case EMPTY:
8671           case MULTISET:
8672           case SUBMULTISET:
8673           case LEADING:
8674           case TRAILING:
8675           case CHAR_CS:
8676           case NCHAR_CS:
8677           case DBTIMEZONE:
8678           case SESSIONTIMEZONE:
8679           case AUTHENTICATED:
8680           case LINK:
8681           case SHARED:
8682           case DIRECTORY:
8683           case USER:
8684           case IDENTIFIER:
8685           case UNSIGNED_NUMERIC_LITERAL:
8686           case CHARACTER_LITERAL:
8687           case STRING_LITERAL:
8688           case QUOTED_LITERAL:
8689             ;
8690             break;
8691           default:
8692             jj_la1[116] = jj_gen;
8693             break label_22;
8694           }
8695         }
8696       }
8697       switch (jj_nt.kind) {
8698       case WHEN:
8699         jj_consume_token(WHEN);
8700         jj_consume_token(OTHERS);
8701         jj_consume_token(THEN);
8702         label_23:
8703         while (true) {
8704           Statement();
8705           switch (jj_nt.kind) {
8706           case 5:
8707           case 16:
8708           case 17:
8709           case 21:
8710           case REPLACE:
8711           case DEFINER:
8712           case CURRENT_USER:
8713           case LANGUAGE:
8714           case INLINE:
8715           case ADD:
8716           case AGGREGATE:
8717           case ARRAY:
8718           case AT:
8719           case ATTRIBUTE:
8720           case AUTHID:
8721           case BEGIN:
8722           case BODY:
8723           case BULK:
8724           case BYTE:
8725           case CASCADE:
8726           case CASE:
8727           case CLOSE:
8728           case COALESCE:
8729           case COLLECT:
8730           case COLUMN:
8731           case COMMENT:
8732           case COMMIT:
8733           case CONSTRUCTOR:
8734           case CONTINUE:
8735           case CONVERT:
8736           case CURRENT:
8737           case CURSOR:
8738           case DATA:
8739           case DATE:
8740           case DAY:
8741           case DECLARE:
8742           case DELETE:
8743           case DISABLE:
8744           case EDITIONABLE:
8745           case ELEMENT:
8746           case ENABLE:
8747           case ESCAPE:
8748           case EXCEPT:
8749           case EXCEPTIONS:
8750           case EXECUTE:
8751           case EXIT:
8752           case EXTERNAL:
8753           case EXTENDS:
8754           case EXTRACT:
8755           case FALSE:
8756           case FETCH:
8757           case FINAL:
8758           case FOR:
8759           case FORALL:
8760           case FORCE:
8761           case FUNCTION:
8762           case GLOBAL:
8763           case GOTO:
8764           case HASH:
8765           case HEAP:
8766           case HOUR:
8767           case IF:
8768           case IMMEDIATE:
8769           case INDICES:
8770           case INDEXTYPE:
8771           case INDICATOR:
8772           case INSERT:
8773           case INSTANTIABLE:
8774           case INTERVAL:
8775           case INVALIDATE:
8776           case ISOLATION:
8777           case JAVA:
8778           case LEVEL:
8779           case LIMIT:
8780           case LOCK:
8781           case LOOP:
8782           case MAP:
8783           case MAX:
8784           case MEMBER:
8785           case MERGE:
8786           case MIN:
8787           case MINUTE:
8788           case MLSLABEL:
8789           case MODIFY:
8790           case MOD:
8791           case MONTH:
8792           case NATURAL:
8793           case NEW:
8794           case NEW_DOT:
8795           case NO:
8796           case NONEDITIONABLE:
8797           case NOT:
8798           case NULL:
8799           case NULLIF:
8800           case OBJECT:
8801           case OID:
8802           case OPAQUE:
8803           case OPEN:
8804           case OPERATOR:
8805           case ORGANIZATION:
8806           case OTHERS:
8807           case OVERRIDING:
8808           case PACKAGE:
8809           case PARTITION:
8810           case PIPE:
8811           case PRAGMA:
8812           case PRESERVE:
8813           case PRIVATE:
8814           case PROCEDURE:
8815           case RAISE:
8816           case RANGE:
8817           case RAW:
8818           case REAL:
8819           case RECORD:
8820           case REF:
8821           case RELEASE:
8822           case RELIES_ON:
8823           case RENAME:
8824           case RESULT:
8825           case RETURN:
8826           case RETURNING:
8827           case REVERSE:
8828           case ROLLBACK:
8829           case ROW:
8830           case ROWS:
8831           case ROWID:
8832           case ROWNUM:
8833           case SAVE:
8834           case SAVEPOINT:
8835           case SECOND:
8836           case SELECT:
8837           case SELF:
8838           case SET:
8839           case SPACE:
8840           case SQL:
8841           case SQLCODE:
8842           case SQLERRM:
8843           case STATIC:
8844           case SUBTYPE:
8845           case SUBSTITUTABLE:
8846           case SUCCESSFUL:
8847           case SYSDATE:
8848           case SYS_REFCURSOR:
8849           case TEMPORARY:
8850           case TIME:
8851           case TIMESTAMP:
8852           case TIMEZONE_REGION:
8853           case TIMEZONE_ABBR:
8854           case TIMEZONE_MINUTE:
8855           case TIMEZONE_HOUR:
8856           case TRANSACTION:
8857           case TRUE:
8858           case TYPE:
8859           case UNDER:
8860           case USING:
8861           case WHILE:
8862           case YES:
8863           case SHOW:
8864           case A:
8865           case UPDATE:
8866           case DOUBLE:
8867           case DEC:
8868           case PRECISION:
8869           case INT:
8870           case NUMERIC:
8871           case NCHAR:
8872           case NVARCHAR2:
8873           case STRING:
8874           case UROWID:
8875           case VARRAY:
8876           case VARYING:
8877           case BFILE:
8878           case BLOB:
8879           case CLOB:
8880           case NCLOB:
8881           case YEAR:
8882           case LOCAL:
8883           case WITH:
8884           case ZONE:
8885           case CHARACTER:
8886           case AFTER:
8887           case BEFORE:
8888           case OLD:
8889           case PARENT:
8890           case CC_IF:
8891           case CC_ERROR:
8892           case ANALYZE:
8893           case ASSOCIATE:
8894           case AUDIT:
8895           case COMPOUND:
8896           case DATABASE:
8897           case CALL:
8898           case DDL:
8899           case DISASSOCIATE:
8900           case EACH:
8901           case FOLLOWS:
8902           case LOGOFF:
8903           case LOGON:
8904           case NESTED:
8905           case NOAUDIT:
8906           case SCHEMA:
8907           case SERVERERROR:
8908           case SHUTDOWN:
8909           case STARTUP:
8910           case STATEMENT:
8911           case STATISTICS:
8912           case SUSPEND:
8913           case TRUNCATE:
8914           case WRAPPED:
8915           case LIBRARY:
8916           case NAME:
8917           case STRUCT:
8918           case CONTEXT:
8919           case PARAMETERS:
8920           case LENGTH:
8921           case TDO:
8922           case MAXLEN:
8923           case CHARSETID:
8924           case CHARSETFORM:
8925           case ACCEPT:
8926           case ACCESSIBLE:
8927           case COPY:
8928           case DEFINE:
8929           case DISCONNECT:
8930           case HOST:
8931           case PRINT:
8932           case QUIT:
8933           case REMARK:
8934           case UNDEFINE:
8935           case VARIABLE:
8936           case WHENEVER:
8937           case ATTACH:
8938           case CAST:
8939           case TREAT:
8940           case TRIM:
8941           case LEFT:
8942           case RIGHT:
8943           case BOTH:
8944           case EMPTY:
8945           case MULTISET:
8946           case SUBMULTISET:
8947           case LEADING:
8948           case TRAILING:
8949           case CHAR_CS:
8950           case NCHAR_CS:
8951           case DBTIMEZONE:
8952           case SESSIONTIMEZONE:
8953           case AUTHENTICATED:
8954           case LINK:
8955           case SHARED:
8956           case DIRECTORY:
8957           case USER:
8958           case IDENTIFIER:
8959           case UNSIGNED_NUMERIC_LITERAL:
8960           case CHARACTER_LITERAL:
8961           case STRING_LITERAL:
8962           case QUOTED_LITERAL:
8963             ;
8964             break;
8965           default:
8966             jj_la1[117] = jj_gen;
8967             break label_23;
8968           }
8969         }
8970         break;
8971       default:
8972         jj_la1[118] = jj_gen;
8973         ;
8974       }
8975         jjtree.closeNodeScope(jjtn000, true);
8976         jjtc000 = false;
8977         {if (true) return jjtn000 ;}
8978     } catch (Throwable jjte000) {
8979         if (jjtc000) {
8980           jjtree.clearNodeScope(jjtn000);
8981           jjtc000 = false;
8982         } else {
8983           jjtree.popNode();
8984         }
8985         if (jjte000 instanceof RuntimeException) {
8986           {if (true) throw (RuntimeException)jjte000;}
8987         }
8988         if (jjte000 instanceof ParseException) {
8989           {if (true) throw (ParseException)jjte000;}
8990         }
8991         {if (true) throw (Error)jjte000;}
8992     } finally {
8993         if (jjtc000) {
8994           jjtree.closeNodeScope(jjtn000, true);
8995         }
8996     }
8997     throw new Error("Missing return statement in function");
8998   }
8999 
9000   final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001  /*@bgen(jjtree) Skip2NextTerminator */
9002   ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003   boolean jjtc000 = true;
9004   jjtree.openNodeScope(jjtn000);Token beginToken = getToken(0);
9005   Token t = getToken(1);
9006   int count = (initiator == null) ? 0 : 1;
9007   if(t.image.equals(initiator)) count++;
9008   while (count > 0 || !t.image.equals(terminator))
9009   {
9010     t = getNextToken();
9011     t = getToken(1);
9012           if(t.image.equals(initiator)) count++;
9013           if(t.image.equals(terminator)) count--;
9014     if((null != t.specialToken && beginToken.kind != SELECT && beginToken.kind != INSERT && beginToken.kind != UPDATE && beginToken.kind != DELETE && beginToken.kind != MERGE) || t.kind == EOF)
9015         return;
9016     if (t.specialToken != null && "/".equals(t.image))
9017             return;
9018   }
9019     try {
9020           jjtree.closeNodeScope(jjtn000, true);
9021           jjtc000 = false;
9022           {if (true) return;}
9023     } finally {
9024           if (jjtc000) {
9025             jjtree.closeNodeScope(jjtn000, true);
9026           }
9027     }
9028   }
9029 
9030 /*
9031  Read Tokens up to but not including the target String. 
9032 */
9033   final public void Skip2NextOccurrence(String target) throws ParseException {
9034  /*@bgen(jjtree) Skip2NextOccurrence */
9035   ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9036   boolean jjtc000 = true;
9037   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9038   while (!nextToken.image.equals(target)
9039          && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) ) //In case the target is a Special Token
9040          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9041         )
9042   {
9043     nextToken = getNextToken();
9044     nextToken = getToken(1);
9045   }
9046     try {
9047           jjtree.closeNodeScope(jjtn000, true);
9048           jjtc000 = false;
9049           {if (true) return;}
9050     } finally {
9051           if (jjtc000) {
9052             jjtree.closeNodeScope(jjtn000, true);
9053           }
9054     }
9055   }
9056 
9057 /*
9058  Read Tokens up to and including the target String. 
9059 */
9060   final public void SkipPastNextOccurrence(String target) throws ParseException {
9061  /*@bgen(jjtree) SkipPastNextOccurrence */
9062   ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9063   boolean jjtc000 = true;
9064   jjtree.openNodeScope(jjtn000);Token t = null;
9065   Skip2NextOccurrence(target) ;
9066   t = getNextToken();
9067     try {
9068           jjtree.closeNodeScope(jjtn000, true);
9069           jjtc000 = false;
9070           {if (true) return;}
9071     } finally {
9072           if (jjtc000) {
9073             jjtree.closeNodeScope(jjtn000, true);
9074           }
9075     }
9076   }
9077 
9078 /*
9079  Read Tokens up to but not including the target Token.kind. 
9080 */
9081   final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9082  /*@bgen(jjtree) Skip2NextTokenOccurrence */
9083   ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9084   boolean jjtc000 = true;
9085   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9086   Token specToken = null ;
9087   while (nextToken.kind!=target
9088          && (null == nextToken.specialToken || nextToken.specialToken.kind!=target ) //In case the target is a Special Token
9089          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9090         )
9091   {
9092     /*
9093 	Check if the target appears as a SpecialToken 
9094 
9095 
9096 	nextToken.specialToken points to the _LAST_ of any SpecialTokens before the current normal Token.
9097 
9098 	It is the head of a doubly-linked list:
9099 
9100 	The ${specialToken}.specialToken field POINTS BACKWARDS TOWARDS the FIRST occurring SpecialToken
9101 	The ${specialToken}.next field POINTS FORWARDS to to the LAST occurring SpecialToken
9102 
9103 	This means that if the program is interested in a specific SpecialToken, it must examine the linked list for every Token which has nexToken.specialToken != null.
9104     
9105     */
9106     specToken = nextToken.specialToken;
9107     if (null!= specToken)
9108     {
9109         //Walk backwards through the list looking for this Token as a Special Token 
9110         while (specToken != null && specToken.kind != target)
9111         {
9112                 specToken = specToken.specialToken;
9113         }
9114 
9115         //We have found the target as a SpecialToken - break out of normal Token search
9116         if (null != specToken && specToken.kind == target)
9117         {
9118                 break;
9119         }
9120     }
9121 
9122     nextToken = getNextToken();
9123     nextToken = getToken(1);
9124   }
9125     try {
9126           jjtree.closeNodeScope(jjtn000, true);
9127           jjtc000 = false;
9128           {if (true) return;}
9129     } finally {
9130           if (jjtc000) {
9131             jjtree.closeNodeScope(jjtn000, true);
9132           }
9133     }
9134   }
9135 
9136 /*
9137  Read Tokens up to and including the target Token.kind. 
9138 */
9139   final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9140  /*@bgen(jjtree) SkipPastNextTokenOccurrence */
9141   ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9142   boolean jjtc000 = true;
9143   jjtree.openNodeScope(jjtn000);Token t = null;
9144   Skip2NextTokenOccurrence(target) ;
9145   t = getNextToken();
9146     try {
9147           jjtree.closeNodeScope(jjtn000, true);
9148           jjtc000 = false;
9149           {if (true) return;}
9150     } finally {
9151           if (jjtc000) {
9152             jjtree.closeNodeScope(jjtn000, true);
9153           }
9154     }
9155   }
9156 
9157 /*
9158  Read Tokens up to but not including the target String. 
9159 */
9160   final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9161  /*@bgen(jjtree) Read2NextOccurrence */
9162   ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9163   boolean jjtc000 = true;
9164   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9165   Token nextToken = getToken(1);
9166   while (!nextToken.image.equals(target)
9167          && nextToken.kind!=EOF
9168         )
9169   {
9170     nextToken = getNextToken();
9171     sb.append(nextToken.image);
9172     nextToken = getToken(1);
9173   }
9174     try {
9175           jjtree.closeNodeScope(jjtn000, true);
9176           jjtc000 = false;
9177           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9178     } finally {
9179           if (jjtc000) {
9180             jjtree.closeNodeScope(jjtn000, true);
9181           }
9182     }
9183     throw new Error("Missing return statement in function");
9184   }
9185 
9186 /*
9187  Read Tokens up to and including the target String. 
9188 */
9189   final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9190  /*@bgen(jjtree) ReadPastNextOccurrence */
9191   ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9192   boolean jjtc000 = true;
9193   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9194   Token t = null;
9195   sb.append(Read2NextOccurrence(target)) ;
9196   t = getNextToken(); // Chomp this one 
9197   sb.append(t.image);
9198     try {
9199           jjtree.closeNodeScope(jjtn000, true);
9200           jjtc000 = false;
9201           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9202     } finally {
9203           if (jjtc000) {
9204             jjtree.closeNodeScope(jjtn000, true);
9205           }
9206     }
9207     throw new Error("Missing return statement in function");
9208   }
9209 
9210 /**
9211  * 2006-05-24 - Matthias Hendler - added MERGE
9212  */
9213   final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9214  /*@bgen(jjtree) SqlStatement */
9215   ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9216   boolean jjtc000 = true;
9217   jjtree.openNodeScope(jjtn000);
9218     try {
9219       switch (jj_nt.kind) {
9220       case SELECT:
9221         jj_consume_token(SELECT);
9222         break;
9223       case UPDATE:
9224         jj_consume_token(UPDATE);
9225         break;
9226       case INSERT:
9227         jj_consume_token(INSERT);
9228         break;
9229       case DELETE:
9230         jj_consume_token(DELETE);
9231         break;
9232       case COMMIT:
9233         jj_consume_token(COMMIT);
9234         break;
9235       case ROLLBACK:
9236         jj_consume_token(ROLLBACK);
9237         break;
9238       case SAVEPOINT:
9239         jj_consume_token(SAVEPOINT);
9240         break;
9241       case EXECUTE:
9242         jj_consume_token(EXECUTE);
9243         break;
9244       case SET:
9245         jj_consume_token(SET);
9246         jj_consume_token(TRANSACTION);
9247         break;
9248       case LOCK:
9249         jj_consume_token(LOCK);
9250         jj_consume_token(TABLE);
9251         break;
9252       case MERGE:
9253         jj_consume_token(MERGE);
9254         break;
9255       case WITH:
9256         jj_consume_token(WITH);
9257         break;
9258       default:
9259         jj_la1[119] = jj_gen;
9260         jj_consume_token(-1);
9261         throw new ParseException();
9262       }
9263       Skip2NextTerminator(initiator,terminator);
9264           jjtree.closeNodeScope(jjtn000, true);
9265           jjtc000 = false;
9266           {if (true) return jjtn000 ;}
9267     } catch (Throwable jjte000) {
9268           if (jjtc000) {
9269             jjtree.clearNodeScope(jjtn000);
9270             jjtc000 = false;
9271           } else {
9272             jjtree.popNode();
9273           }
9274           if (jjte000 instanceof RuntimeException) {
9275             {if (true) throw (RuntimeException)jjte000;}
9276           }
9277           if (jjte000 instanceof ParseException) {
9278             {if (true) throw (ParseException)jjte000;}
9279           }
9280           {if (true) throw (Error)jjte000;}
9281     } finally {
9282           if (jjtc000) {
9283             jjtree.closeNodeScope(jjtn000, true);
9284           }
9285     }
9286     throw new Error("Missing return statement in function");
9287   }
9288 
9289 /**
9290  * 2011-05-15 - SRT - Added to cope with wrapped objects
9291   A wrapped function looks like this (always terminated by one or more equals signs "="):-
9292   "  CREATE OR REPLACE FUNCTION "TESTUSER"."GET_DATE_STRING"
9293 / ** Return SYSDATE formatted using the provided template.
9294  *
9295  *
9296  *  @param p_date_format normal TO_CHARE/TO_DATE date template
9297  *  @return formatted datestring
9298  *  @see http://www.oracle-base.com/articles/10g/WrapAndDBMS_DDL_10gR2.php#dbms_ddl
9299  * /
9300 wrapped
9301 a000000
9302 369
9303 abcd
9304 abcd
9305 abcd
9306 abcd
9307 abcd
9308 abcd
9309 abcd
9310 abcd
9311 abcd
9312 abcd
9313 abcd
9314 abcd
9315 abcd
9316 abcd
9317 abcd
9318 8
9319 89 b6
9320 /SBrhM8+1iUO4QAih+qD2SK8kSowg8eZgcfLCNL+XlquYvSuoVah8JbRPpdHDLHn479SdFLw
9321 v04omzJ0zOfHdMAzuHQlw+fAsr2ym9YI8I521pRTbnFVAHOOUw4JqPkIyj7wj4VwyL17nhYb
9322 3qPVuL6SvhZTmEBnRtaErHpzaDuIpqZ0G4s=
9323   "
9324  */
9325   final public void WrappedObject() throws ParseException {
9326  /*@bgen(jjtree) WrappedObject */
9327   ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9328   boolean jjtc000 = true;
9329   jjtree.openNodeScope(jjtn000);
9330     try {
9331       jj_consume_token(WRAPPED);
9332           jjtree.closeNodeScope(jjtn000, true);
9333           jjtc000 = false;
9334            Token nextToken;
9335 
9336                 nextToken = getToken(1); //ReadAhead
9337                 while (
9338                      null != nextToken && nextToken.kind!=EOF
9339                      )
9340                 {
9341                         nextToken = getNextToken();
9342 
9343                         //Execute manual readahead 
9344                         nextToken = getToken(1); //ReadAhead 1 Token 
9345                 }
9346                 {if (true) return;}
9347     } finally {
9348           if (jjtc000) {
9349             jjtree.closeNodeScope(jjtn000, true);
9350           }
9351     }
9352   }
9353 
9354 // ============================================================================
9355 // S T A T E M E N T S
9356 // ============================================================================
9357 
9358 /**
9359  * 2006-05-24 - Matthias Hendler - added MERGE, EXECUTE choice and LOOKAHEAD at <LOOP>
9360  */
9361   final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9362  /*@bgen(jjtree) UnlabelledStatement */
9363   ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9364   boolean jjtc000 = true;
9365   jjtree.openNodeScope(jjtn000);
9366     try {
9367       if (jj_2_42(2147483647)) {
9368         SqlStatement(null,";");
9369         switch (jj_nt.kind) {
9370         case 4:
9371           jj_consume_token(4);
9372           break;
9373         default:
9374           jj_la1[120] = jj_gen;
9375           ;
9376         }
9377       } else if (jj_2_43(3)) {
9378         ContinueStatement();
9379         jj_consume_token(4);
9380       } else {
9381         switch (jj_nt.kind) {
9382         case CASE:
9383           CaseStatement();
9384           jj_consume_token(4);
9385           break;
9386         case IF:
9387           IfStatement();
9388           jj_consume_token(4);
9389           break;
9390         case FOR:
9391           ForStatement();
9392           jj_consume_token(4);
9393           break;
9394         case FORALL:
9395           ForAllStatement();
9396           jj_consume_token(4);
9397           break;
9398         case LOOP:
9399           LoopStatement();
9400           jj_consume_token(4);
9401           break;
9402         case WHILE:
9403           WhileStatement();
9404           jj_consume_token(4);
9405           break;
9406         case GOTO:
9407           GotoStatement();
9408           jj_consume_token(4);
9409           break;
9410         case RETURN:
9411           ReturnStatement();
9412           jj_consume_token(4);
9413           break;
9414         case EXIT:
9415           ExitStatement();
9416           jj_consume_token(4);
9417           break;
9418         case RAISE:
9419           RaiseStatement();
9420           jj_consume_token(4);
9421           break;
9422         case CLOSE:
9423           CloseStatement();
9424           jj_consume_token(4);
9425           break;
9426         case OPEN:
9427           OpenStatement();
9428           jj_consume_token(4);
9429           break;
9430         case FETCH:
9431           FetchStatement();
9432           jj_consume_token(4);
9433           break;
9434         case BEGIN:
9435         case DECLARE:
9436           Block();
9437           jj_consume_token(4);
9438           break;
9439         case EXECUTE:
9440           EmbeddedSqlStatement();
9441           jj_consume_token(4);
9442           break;
9443         case PIPE:
9444           PipelineStatement();
9445           jj_consume_token(4);
9446           break;
9447         case CC_IF:
9448         case CC_ERROR:
9449           ConditionalCompilationStatement();
9450           break;
9451         case PRAGMA:
9452           InlinePragma();
9453           jj_consume_token(4);
9454           break;
9455         case 5:
9456         case 16:
9457         case 17:
9458         case REPLACE:
9459         case DEFINER:
9460         case CURRENT_USER:
9461         case LANGUAGE:
9462         case INLINE:
9463         case ADD:
9464         case AGGREGATE:
9465         case ARRAY:
9466         case AT:
9467         case ATTRIBUTE:
9468         case AUTHID:
9469         case BODY:
9470         case BULK:
9471         case BYTE:
9472         case CASCADE:
9473         case COALESCE:
9474         case COLLECT:
9475         case COLUMN:
9476         case COMMENT:
9477         case COMMIT:
9478         case CONSTRUCTOR:
9479         case CONTINUE:
9480         case CONVERT:
9481         case CURRENT:
9482         case CURSOR:
9483         case DATA:
9484         case DATE:
9485         case DAY:
9486         case DISABLE:
9487         case EDITIONABLE:
9488         case ELEMENT:
9489         case ENABLE:
9490         case ESCAPE:
9491         case EXCEPT:
9492         case EXCEPTIONS:
9493         case EXTERNAL:
9494         case EXTENDS:
9495         case EXTRACT:
9496         case FALSE:
9497         case FINAL:
9498         case FORCE:
9499         case FUNCTION:
9500         case GLOBAL:
9501         case HASH:
9502         case HEAP:
9503         case HOUR:
9504         case IMMEDIATE:
9505         case INDICES:
9506         case INDEXTYPE:
9507         case INDICATOR:
9508         case INSTANTIABLE:
9509         case INTERVAL:
9510         case INVALIDATE:
9511         case ISOLATION:
9512         case JAVA:
9513         case LEVEL:
9514         case LIMIT:
9515         case MAP:
9516         case MAX:
9517         case MEMBER:
9518         case MERGE:
9519         case MIN:
9520         case MINUTE:
9521         case MLSLABEL:
9522         case MODIFY:
9523         case MOD:
9524         case MONTH:
9525         case NATURAL:
9526         case NEW:
9527         case NEW_DOT:
9528         case NO:
9529         case NONEDITIONABLE:
9530         case NOT:
9531         case NULL:
9532         case NULLIF:
9533         case OBJECT:
9534         case OID:
9535         case OPAQUE:
9536         case OPERATOR:
9537         case ORGANIZATION:
9538         case OTHERS:
9539         case OVERRIDING:
9540         case PACKAGE:
9541         case PARTITION:
9542         case PRESERVE:
9543         case PRIVATE:
9544         case PROCEDURE:
9545         case RANGE:
9546         case RAW:
9547         case REAL:
9548         case RECORD:
9549         case REF:
9550         case RELEASE:
9551         case RELIES_ON:
9552         case RENAME:
9553         case RESULT:
9554         case RETURNING:
9555         case REVERSE:
9556         case ROLLBACK:
9557         case ROW:
9558         case ROWS:
9559         case ROWID:
9560         case ROWNUM:
9561         case SAVE:
9562         case SAVEPOINT:
9563         case SECOND:
9564         case SELECT:
9565         case SELF:
9566         case SET:
9567         case SPACE:
9568         case SQL:
9569         case SQLCODE:
9570         case SQLERRM:
9571         case STATIC:
9572         case SUBTYPE:
9573         case SUBSTITUTABLE:
9574         case SUCCESSFUL:
9575         case SYSDATE:
9576         case SYS_REFCURSOR:
9577         case TEMPORARY:
9578         case TIME:
9579         case TIMESTAMP:
9580         case TIMEZONE_REGION:
9581         case TIMEZONE_ABBR:
9582         case TIMEZONE_MINUTE:
9583         case TIMEZONE_HOUR:
9584         case TRANSACTION:
9585         case TRUE:
9586         case TYPE:
9587         case UNDER:
9588         case USING:
9589         case YES:
9590         case SHOW:
9591         case A:
9592         case DOUBLE:
9593         case DEC:
9594         case PRECISION:
9595         case INT:
9596         case NUMERIC:
9597         case NCHAR:
9598         case NVARCHAR2:
9599         case STRING:
9600         case UROWID:
9601         case VARRAY:
9602         case VARYING:
9603         case BFILE:
9604         case BLOB:
9605         case CLOB:
9606         case NCLOB:
9607         case YEAR:
9608         case LOCAL:
9609         case WITH:
9610         case ZONE:
9611         case CHARACTER:
9612         case AFTER:
9613         case BEFORE:
9614         case OLD:
9615         case PARENT:
9616         case ANALYZE:
9617         case ASSOCIATE:
9618         case AUDIT:
9619         case COMPOUND:
9620         case DATABASE:
9621         case CALL:
9622         case DDL:
9623         case DISASSOCIATE:
9624         case EACH:
9625         case FOLLOWS:
9626         case LOGOFF:
9627         case LOGON:
9628         case NESTED:
9629         case NOAUDIT:
9630         case SCHEMA:
9631         case SERVERERROR:
9632         case SHUTDOWN:
9633         case STARTUP:
9634         case STATEMENT:
9635         case STATISTICS:
9636         case SUSPEND:
9637         case TRUNCATE:
9638         case WRAPPED:
9639         case LIBRARY:
9640         case NAME:
9641         case STRUCT:
9642         case CONTEXT:
9643         case PARAMETERS:
9644         case LENGTH:
9645         case TDO:
9646         case MAXLEN:
9647         case CHARSETID:
9648         case CHARSETFORM:
9649         case ACCEPT:
9650         case ACCESSIBLE:
9651         case COPY:
9652         case DEFINE:
9653         case DISCONNECT:
9654         case HOST:
9655         case PRINT:
9656         case QUIT:
9657         case REMARK:
9658         case UNDEFINE:
9659         case VARIABLE:
9660         case WHENEVER:
9661         case ATTACH:
9662         case CAST:
9663         case TREAT:
9664         case TRIM:
9665         case LEFT:
9666         case RIGHT:
9667         case BOTH:
9668         case EMPTY:
9669         case MULTISET:
9670         case SUBMULTISET:
9671         case LEADING:
9672         case TRAILING:
9673         case CHAR_CS:
9674         case NCHAR_CS:
9675         case DBTIMEZONE:
9676         case SESSIONTIMEZONE:
9677         case AUTHENTICATED:
9678         case LINK:
9679         case SHARED:
9680         case DIRECTORY:
9681         case USER:
9682         case IDENTIFIER:
9683         case UNSIGNED_NUMERIC_LITERAL:
9684         case CHARACTER_LITERAL:
9685         case STRING_LITERAL:
9686         case QUOTED_LITERAL:
9687           Expression();
9688           jj_consume_token(4);
9689           break;
9690         default:
9691           jj_la1[121] = jj_gen;
9692           jj_consume_token(-1);
9693           throw new ParseException();
9694         }
9695       }
9696         jjtree.closeNodeScope(jjtn000, true);
9697         jjtc000 = false;
9698         {if (true) return jjtn000 ;}
9699     } catch (Throwable jjte000) {
9700          if (jjtc000) {
9701            jjtree.clearNodeScope(jjtn000);
9702            jjtc000 = false;
9703          } else {
9704            jjtree.popNode();
9705          }
9706          if (jjte000 instanceof RuntimeException) {
9707            {if (true) throw (RuntimeException)jjte000;}
9708          }
9709          if (jjte000 instanceof ParseException) {
9710            {if (true) throw (ParseException)jjte000;}
9711          }
9712          {if (true) throw (Error)jjte000;}
9713     } finally {
9714          if (jjtc000) {
9715            jjtree.closeNodeScope(jjtn000, true);
9716          }
9717     }
9718     throw new Error("Missing return statement in function");
9719   }
9720 
9721   final public ASTStatement Statement() throws ParseException {
9722  /*@bgen(jjtree) Statement */
9723   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9724   boolean jjtc000 = true;
9725   jjtree.openNodeScope(jjtn000);
9726     try {
9727       switch (jj_nt.kind) {
9728       case 21:
9729         LabelledStatement();
9730         break;
9731       case 5:
9732       case 16:
9733       case 17:
9734       case REPLACE:
9735       case DEFINER:
9736       case CURRENT_USER:
9737       case LANGUAGE:
9738       case INLINE:
9739       case ADD:
9740       case AGGREGATE:
9741       case ARRAY:
9742       case AT:
9743       case ATTRIBUTE:
9744       case AUTHID:
9745       case BEGIN:
9746       case BODY:
9747       case BULK:
9748       case BYTE:
9749       case CASCADE:
9750       case CASE:
9751       case CLOSE:
9752       case COALESCE:
9753       case COLLECT:
9754       case COLUMN:
9755       case COMMENT:
9756       case COMMIT:
9757       case CONSTRUCTOR:
9758       case CONTINUE:
9759       case CONVERT:
9760       case CURRENT:
9761       case CURSOR:
9762       case DATA:
9763       case DATE:
9764       case DAY:
9765       case DECLARE:
9766       case DELETE:
9767       case DISABLE:
9768       case EDITIONABLE:
9769       case ELEMENT:
9770       case ENABLE:
9771       case ESCAPE:
9772       case EXCEPT:
9773       case EXCEPTIONS:
9774       case EXECUTE:
9775       case EXIT:
9776       case EXTERNAL:
9777       case EXTENDS:
9778       case EXTRACT:
9779       case FALSE:
9780       case FETCH:
9781       case FINAL:
9782       case FOR:
9783       case FORALL:
9784       case FORCE:
9785       case FUNCTION:
9786       case GLOBAL:
9787       case GOTO:
9788       case HASH:
9789       case HEAP:
9790       case HOUR:
9791       case IF:
9792       case IMMEDIATE:
9793       case INDICES:
9794       case INDEXTYPE:
9795       case INDICATOR:
9796       case INSERT:
9797       case INSTANTIABLE:
9798       case INTERVAL:
9799       case INVALIDATE:
9800       case ISOLATION:
9801       case JAVA:
9802       case LEVEL:
9803       case LIMIT:
9804       case LOCK:
9805       case LOOP:
9806       case MAP:
9807       case MAX:
9808       case MEMBER:
9809       case MERGE:
9810       case MIN:
9811       case MINUTE:
9812       case MLSLABEL:
9813       case MODIFY:
9814       case MOD:
9815       case MONTH:
9816       case NATURAL:
9817       case NEW:
9818       case NEW_DOT:
9819       case NO:
9820       case NONEDITIONABLE:
9821       case NOT:
9822       case NULL:
9823       case NULLIF:
9824       case OBJECT:
9825       case OID:
9826       case OPAQUE:
9827       case OPEN:
9828       case OPERATOR:
9829       case ORGANIZATION:
9830       case OTHERS:
9831       case OVERRIDING:
9832       case PACKAGE:
9833       case PARTITION:
9834       case PIPE:
9835       case PRAGMA:
9836       case PRESERVE:
9837       case PRIVATE:
9838       case PROCEDURE:
9839       case RAISE:
9840       case RANGE:
9841       case RAW:
9842       case REAL:
9843       case RECORD:
9844       case REF:
9845       case RELEASE:
9846       case RELIES_ON:
9847       case RENAME:
9848       case RESULT:
9849       case RETURN:
9850       case RETURNING:
9851       case REVERSE:
9852       case ROLLBACK:
9853       case ROW:
9854       case ROWS:
9855       case ROWID:
9856       case ROWNUM:
9857       case SAVE:
9858       case SAVEPOINT:
9859       case SECOND:
9860       case SELECT:
9861       case SELF:
9862       case SET:
9863       case SPACE:
9864       case SQL:
9865       case SQLCODE:
9866       case SQLERRM:
9867       case STATIC:
9868       case SUBTYPE:
9869       case SUBSTITUTABLE:
9870       case SUCCESSFUL:
9871       case SYSDATE:
9872       case SYS_REFCURSOR:
9873       case TEMPORARY:
9874       case TIME:
9875       case TIMESTAMP:
9876       case TIMEZONE_REGION:
9877       case TIMEZONE_ABBR:
9878       case TIMEZONE_MINUTE:
9879       case TIMEZONE_HOUR:
9880       case TRANSACTION:
9881       case TRUE:
9882       case TYPE:
9883       case UNDER:
9884       case USING:
9885       case WHILE:
9886       case YES:
9887       case SHOW:
9888       case A:
9889       case UPDATE:
9890       case DOUBLE:
9891       case DEC:
9892       case PRECISION:
9893       case INT:
9894       case NUMERIC:
9895       case NCHAR:
9896       case NVARCHAR2:
9897       case STRING:
9898       case UROWID:
9899       case VARRAY:
9900       case VARYING:
9901       case BFILE:
9902       case BLOB:
9903       case CLOB:
9904       case NCLOB:
9905       case YEAR:
9906       case LOCAL:
9907       case WITH:
9908       case ZONE:
9909       case CHARACTER:
9910       case AFTER:
9911       case BEFORE:
9912       case OLD:
9913       case PARENT:
9914       case CC_IF:
9915       case CC_ERROR:
9916       case ANALYZE:
9917       case ASSOCIATE:
9918       case AUDIT:
9919       case COMPOUND:
9920       case DATABASE:
9921       case CALL:
9922       case DDL:
9923       case DISASSOCIATE:
9924       case EACH:
9925       case FOLLOWS:
9926       case LOGOFF:
9927       case LOGON:
9928       case NESTED:
9929       case NOAUDIT:
9930       case SCHEMA:
9931       case SERVERERROR:
9932       case SHUTDOWN:
9933       case STARTUP:
9934       case STATEMENT:
9935       case STATISTICS:
9936       case SUSPEND:
9937       case TRUNCATE:
9938       case WRAPPED:
9939       case LIBRARY:
9940       case NAME:
9941       case STRUCT:
9942       case CONTEXT:
9943       case PARAMETERS:
9944       case LENGTH:
9945       case TDO:
9946       case MAXLEN:
9947       case CHARSETID:
9948       case CHARSETFORM:
9949       case ACCEPT:
9950       case ACCESSIBLE:
9951       case COPY:
9952       case DEFINE:
9953       case DISCONNECT:
9954       case HOST:
9955       case PRINT:
9956       case QUIT:
9957       case REMARK:
9958       case UNDEFINE:
9959       case VARIABLE:
9960       case WHENEVER:
9961       case ATTACH:
9962       case CAST:
9963       case TREAT:
9964       case TRIM:
9965       case LEFT:
9966       case RIGHT:
9967       case BOTH:
9968       case EMPTY:
9969       case MULTISET:
9970       case SUBMULTISET:
9971       case LEADING:
9972       case TRAILING:
9973       case CHAR_CS:
9974       case NCHAR_CS:
9975       case DBTIMEZONE:
9976       case SESSIONTIMEZONE:
9977       case AUTHENTICATED:
9978       case LINK:
9979       case SHARED:
9980       case DIRECTORY:
9981       case USER:
9982       case IDENTIFIER:
9983       case UNSIGNED_NUMERIC_LITERAL:
9984       case CHARACTER_LITERAL:
9985       case STRING_LITERAL:
9986       case QUOTED_LITERAL:
9987         UnlabelledStatement();
9988         break;
9989       default:
9990         jj_la1[122] = jj_gen;
9991         jj_consume_token(-1);
9992         throw new ParseException();
9993       }
9994         jjtree.closeNodeScope(jjtn000, true);
9995         jjtc000 = false;
9996         {if (true) return jjtn000 ;}
9997     } catch (Throwable jjte000) {
9998         if (jjtc000) {
9999           jjtree.clearNodeScope(jjtn000);
10000           jjtc000 = false;
10001         } else {
10002           jjtree.popNode();
10003         }
10004         if (jjte000 instanceof RuntimeException) {
10005           {if (true) throw (RuntimeException)jjte000;}
10006         }
10007         if (jjte000 instanceof ParseException) {
10008           {if (true) throw (ParseException)jjte000;}
10009         }
10010         {if (true) throw (Error)jjte000;}
10011     } finally {
10012         if (jjtc000) {
10013           jjtree.closeNodeScope(jjtn000, true);
10014         }
10015     }
10016     throw new Error("Missing return statement in function");
10017   }
10018 
10019 /*
10020 LabelledStatement created solely to conform with PMD Java AST (for PMD DataFlow Analysis - DFA)
10021 N.B. equivalent Java AST* class is ASTLabeledStatement (single "l" rather than double "ll")
10022 */
10023   final public ASTLabelledStatement LabelledStatement() throws ParseException {
10024  /*@bgen(jjtree) LabelledStatement */
10025 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10026 boolean jjtc000 = true;
10027 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10028     try {
10029       label_24:
10030       while (true) {
10031         simpleNode = Label();
10032         switch (jj_nt.kind) {
10033         case 21:
10034           ;
10035           break;
10036         default:
10037           jj_la1[123] = jj_gen;
10038           break label_24;
10039         }
10040       }
10041       UnlabelledStatement();
10042         jjtree.closeNodeScope(jjtn000, true);
10043         jjtc000 = false;
10044         jjtn000.setImage( simpleNode.getImage() ) ;
10045        {if (true) return jjtn000 ;}
10046     } catch (Throwable jjte000) {
10047         if (jjtc000) {
10048           jjtree.clearNodeScope(jjtn000);
10049           jjtc000 = false;
10050         } else {
10051           jjtree.popNode();
10052         }
10053         if (jjte000 instanceof RuntimeException) {
10054           {if (true) throw (RuntimeException)jjte000;}
10055         }
10056         if (jjte000 instanceof ParseException) {
10057           {if (true) throw (ParseException)jjte000;}
10058         }
10059         {if (true) throw (Error)jjte000;}
10060     } finally {
10061         if (jjtc000) {
10062           jjtree.closeNodeScope(jjtn000, true);
10063         }
10064     }
10065     throw new Error("Missing return statement in function");
10066   }
10067 
10068   final public ASTCaseStatement CaseStatement() throws ParseException {
10069  /*@bgen(jjtree) CaseStatement */
10070   ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10071   boolean jjtc000 = true;
10072   jjtree.openNodeScope(jjtn000);
10073     try {
10074       jj_consume_token(CASE);
10075       switch (jj_nt.kind) {
10076       case 5:
10077       case 16:
10078       case 17:
10079       case REPLACE:
10080       case DEFINER:
10081       case CURRENT_USER:
10082       case LANGUAGE:
10083       case INLINE:
10084       case ADD:
10085       case AGGREGATE:
10086       case ARRAY:
10087       case AT:
10088       case ATTRIBUTE:
10089       case AUTHID:
10090       case BODY:
10091       case BULK:
10092       case BYTE:
10093       case CASCADE:
10094       case CASE:
10095       case CLOSE:
10096       case COALESCE:
10097       case COLLECT:
10098       case COLUMN:
10099       case COMMENT:
10100       case COMMIT:
10101       case CONSTRUCTOR:
10102       case CONTINUE:
10103       case CONVERT:
10104       case CURRENT:
10105       case CURSOR:
10106       case DATA:
10107       case DATE:
10108       case DAY:
10109       case DISABLE:
10110       case EDITIONABLE:
10111       case ELEMENT:
10112       case ENABLE:
10113       case ESCAPE:
10114       case EXCEPT:
10115       case EXCEPTIONS:
10116       case EXIT:
10117       case EXTERNAL:
10118       case EXTENDS:
10119       case EXTRACT:
10120       case FALSE:
10121       case FINAL:
10122       case FORCE:
10123       case FUNCTION:
10124       case GLOBAL:
10125       case HASH:
10126       case HEAP:
10127       case HOUR:
10128       case IMMEDIATE:
10129       case INDICES:
10130       case INDEXTYPE:
10131       case INDICATOR:
10132       case INSTANTIABLE:
10133       case INTERVAL:
10134       case INVALIDATE:
10135       case ISOLATION:
10136       case JAVA:
10137       case LEVEL:
10138       case LIMIT:
10139       case LOOP:
10140       case MAP:
10141       case MAX:
10142       case MEMBER:
10143       case MERGE:
10144       case MIN:
10145       case MINUTE:
10146       case MLSLABEL:
10147       case MODIFY:
10148       case MOD:
10149       case MONTH:
10150       case NATURAL:
10151       case NEW:
10152       case NEW_DOT:
10153       case NO:
10154       case NONEDITIONABLE:
10155       case NOT:
10156       case NULL:
10157       case NULLIF:
10158       case OBJECT:
10159       case OID:
10160       case OPAQUE:
10161       case OPEN:
10162       case OPERATOR:
10163       case ORGANIZATION:
10164       case OTHERS:
10165       case OVERRIDING:
10166       case PACKAGE:
10167       case PARTITION:
10168       case PRESERVE:
10169       case PRIVATE:
10170       case PROCEDURE:
10171       case RANGE:
10172       case RAW:
10173       case REAL:
10174       case RECORD:
10175       case REF:
10176       case RELEASE:
10177       case RELIES_ON:
10178       case RENAME:
10179       case RESULT:
10180       case RETURN:
10181       case RETURNING:
10182       case REVERSE:
10183       case ROLLBACK:
10184       case ROW:
10185       case ROWS:
10186       case ROWID:
10187       case ROWNUM:
10188       case SAVE:
10189       case SAVEPOINT:
10190       case SECOND:
10191       case SELECT:
10192       case SELF:
10193       case SET:
10194       case SPACE:
10195       case SQL:
10196       case SQLCODE:
10197       case SQLERRM:
10198       case STATIC:
10199       case SUBTYPE:
10200       case SUBSTITUTABLE:
10201       case SUCCESSFUL:
10202       case SYSDATE:
10203       case SYS_REFCURSOR:
10204       case TEMPORARY:
10205       case TIME:
10206       case TIMESTAMP:
10207       case TIMEZONE_REGION:
10208       case TIMEZONE_ABBR:
10209       case TIMEZONE_MINUTE:
10210       case TIMEZONE_HOUR:
10211       case TRANSACTION:
10212       case TRUE:
10213       case TYPE:
10214       case UNDER:
10215       case USING:
10216       case YES:
10217       case SHOW:
10218       case A:
10219       case DOUBLE:
10220       case DEC:
10221       case PRECISION:
10222       case INT:
10223       case NUMERIC:
10224       case NCHAR:
10225       case NVARCHAR2:
10226       case STRING:
10227       case UROWID:
10228       case VARRAY:
10229       case VARYING:
10230       case BFILE:
10231       case BLOB:
10232       case CLOB:
10233       case NCLOB:
10234       case YEAR:
10235       case LOCAL:
10236       case WITH:
10237       case ZONE:
10238       case CHARACTER:
10239       case AFTER:
10240       case BEFORE:
10241       case OLD:
10242       case PARENT:
10243       case CC_IF:
10244       case ANALYZE:
10245       case ASSOCIATE:
10246       case AUDIT:
10247       case COMPOUND:
10248       case DATABASE:
10249       case CALL:
10250       case DDL:
10251       case DISASSOCIATE:
10252       case EACH:
10253       case FOLLOWS:
10254       case LOGOFF:
10255       case LOGON:
10256       case NESTED:
10257       case NOAUDIT:
10258       case SCHEMA:
10259       case SERVERERROR:
10260       case SHUTDOWN:
10261       case STARTUP:
10262       case STATEMENT:
10263       case STATISTICS:
10264       case SUSPEND:
10265       case TRUNCATE:
10266       case WRAPPED:
10267       case LIBRARY:
10268       case NAME:
10269       case STRUCT:
10270       case CONTEXT:
10271       case PARAMETERS:
10272       case LENGTH:
10273       case TDO:
10274       case MAXLEN:
10275       case CHARSETID:
10276       case CHARSETFORM:
10277       case ACCEPT:
10278       case ACCESSIBLE:
10279       case COPY:
10280       case DEFINE:
10281       case DISCONNECT:
10282       case HOST:
10283       case PRINT:
10284       case QUIT:
10285       case REMARK:
10286       case UNDEFINE:
10287       case VARIABLE:
10288       case WHENEVER:
10289       case ATTACH:
10290       case CAST:
10291       case TREAT:
10292       case TRIM:
10293       case LEFT:
10294       case RIGHT:
10295       case BOTH:
10296       case EMPTY:
10297       case MULTISET:
10298       case SUBMULTISET:
10299       case LEADING:
10300       case TRAILING:
10301       case CHAR_CS:
10302       case NCHAR_CS:
10303       case DBTIMEZONE:
10304       case SESSIONTIMEZONE:
10305       case AUTHENTICATED:
10306       case LINK:
10307       case SHARED:
10308       case DIRECTORY:
10309       case USER:
10310       case IDENTIFIER:
10311       case UNSIGNED_NUMERIC_LITERAL:
10312       case CHARACTER_LITERAL:
10313       case STRING_LITERAL:
10314       case QUOTED_LITERAL:
10315         Expression();
10316         break;
10317       default:
10318         jj_la1[124] = jj_gen;
10319         ;
10320       }
10321       label_25:
10322       while (true) {
10323         switch (jj_nt.kind) {
10324         case WHEN:
10325           ;
10326           break;
10327         default:
10328           jj_la1[125] = jj_gen;
10329           break label_25;
10330         }
10331         CaseWhenClause();
10332       }
10333       switch (jj_nt.kind) {
10334       case ELSE:
10335         ElseClause();
10336         break;
10337       default:
10338         jj_la1[126] = jj_gen;
10339         ;
10340       }
10341       jj_consume_token(END);
10342       jj_consume_token(CASE);
10343       switch (jj_nt.kind) {
10344       case IDENTIFIER:
10345         jj_consume_token(IDENTIFIER);
10346         break;
10347       default:
10348         jj_la1[127] = jj_gen;
10349         ;
10350       }
10351         jjtree.closeNodeScope(jjtn000, true);
10352         jjtc000 = false;
10353         {if (true) return jjtn000 ;}
10354     } catch (Throwable jjte000) {
10355          if (jjtc000) {
10356            jjtree.clearNodeScope(jjtn000);
10357            jjtc000 = false;
10358          } else {
10359            jjtree.popNode();
10360          }
10361          if (jjte000 instanceof RuntimeException) {
10362            {if (true) throw (RuntimeException)jjte000;}
10363          }
10364          if (jjte000 instanceof ParseException) {
10365            {if (true) throw (ParseException)jjte000;}
10366          }
10367          {if (true) throw (Error)jjte000;}
10368     } finally {
10369          if (jjtc000) {
10370            jjtree.closeNodeScope(jjtn000, true);
10371          }
10372     }
10373     throw new Error("Missing return statement in function");
10374   }
10375 
10376   final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10377  /*@bgen(jjtree) CaseWhenClause */
10378   ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10379   boolean jjtc000 = true;
10380   jjtree.openNodeScope(jjtn000);
10381     try {
10382       jj_consume_token(WHEN);
10383       Expression();
10384       jj_consume_token(THEN);
10385       label_26:
10386       while (true) {
10387         Statement();
10388         switch (jj_nt.kind) {
10389         case 5:
10390         case 16:
10391         case 17:
10392         case 21:
10393         case REPLACE:
10394         case DEFINER:
10395         case CURRENT_USER:
10396         case LANGUAGE:
10397         case INLINE:
10398         case ADD:
10399         case AGGREGATE:
10400         case ARRAY:
10401         case AT:
10402         case ATTRIBUTE:
10403         case AUTHID:
10404         case BEGIN:
10405         case BODY:
10406         case BULK:
10407         case BYTE:
10408         case CASCADE:
10409         case CASE:
10410         case CLOSE:
10411         case COALESCE:
10412         case COLLECT:
10413         case COLUMN:
10414         case COMMENT:
10415         case COMMIT:
10416         case CONSTRUCTOR:
10417         case CONTINUE:
10418         case CONVERT:
10419         case CURRENT:
10420         case CURSOR:
10421         case DATA:
10422         case DATE:
10423         case DAY:
10424         case DECLARE:
10425         case DELETE:
10426         case DISABLE:
10427         case EDITIONABLE:
10428         case ELEMENT:
10429         case ENABLE:
10430         case ESCAPE:
10431         case EXCEPT:
10432         case EXCEPTIONS:
10433         case EXECUTE:
10434         case EXIT:
10435         case EXTERNAL:
10436         case EXTENDS:
10437         case EXTRACT:
10438         case FALSE:
10439         case FETCH:
10440         case FINAL:
10441         case FOR:
10442         case FORALL:
10443         case FORCE:
10444         case FUNCTION:
10445         case GLOBAL:
10446         case GOTO:
10447         case HASH:
10448         case HEAP:
10449         case HOUR:
10450         case IF:
10451         case IMMEDIATE:
10452         case INDICES:
10453         case INDEXTYPE:
10454         case INDICATOR:
10455         case INSERT:
10456         case INSTANTIABLE:
10457         case INTERVAL:
10458         case INVALIDATE:
10459         case ISOLATION:
10460         case JAVA:
10461         case LEVEL:
10462         case LIMIT:
10463         case LOCK:
10464         case LOOP:
10465         case MAP:
10466         case MAX:
10467         case MEMBER:
10468         case MERGE:
10469         case MIN:
10470         case MINUTE:
10471         case MLSLABEL:
10472         case MODIFY:
10473         case MOD:
10474         case MONTH:
10475         case NATURAL:
10476         case NEW:
10477         case NEW_DOT:
10478         case NO:
10479         case NONEDITIONABLE:
10480         case NOT:
10481         case NULL:
10482         case NULLIF:
10483         case OBJECT:
10484         case OID:
10485         case OPAQUE:
10486         case OPEN:
10487         case OPERATOR:
10488         case ORGANIZATION:
10489         case OTHERS:
10490         case OVERRIDING:
10491         case PACKAGE:
10492         case PARTITION:
10493         case PIPE:
10494         case PRAGMA:
10495         case PRESERVE:
10496         case PRIVATE:
10497         case PROCEDURE:
10498         case RAISE:
10499         case RANGE:
10500         case RAW:
10501         case REAL:
10502         case RECORD:
10503         case REF:
10504         case RELEASE:
10505         case RELIES_ON:
10506         case RENAME:
10507         case RESULT:
10508         case RETURN:
10509         case RETURNING:
10510         case REVERSE:
10511         case ROLLBACK:
10512         case ROW:
10513         case ROWS:
10514         case ROWID:
10515         case ROWNUM:
10516         case SAVE:
10517         case SAVEPOINT:
10518         case SECOND:
10519         case SELECT:
10520         case SELF:
10521         case SET:
10522         case SPACE:
10523         case SQL:
10524         case SQLCODE:
10525         case SQLERRM:
10526         case STATIC:
10527         case SUBTYPE:
10528         case SUBSTITUTABLE:
10529         case SUCCESSFUL:
10530         case SYSDATE:
10531         case SYS_REFCURSOR:
10532         case TEMPORARY:
10533         case TIME:
10534         case TIMESTAMP:
10535         case TIMEZONE_REGION:
10536         case TIMEZONE_ABBR:
10537         case TIMEZONE_MINUTE:
10538         case TIMEZONE_HOUR:
10539         case TRANSACTION:
10540         case TRUE:
10541         case TYPE:
10542         case UNDER:
10543         case USING:
10544         case WHILE:
10545         case YES:
10546         case SHOW:
10547         case A:
10548         case UPDATE:
10549         case DOUBLE:
10550         case DEC:
10551         case PRECISION:
10552         case INT:
10553         case NUMERIC:
10554         case NCHAR:
10555         case NVARCHAR2:
10556         case STRING:
10557         case UROWID:
10558         case VARRAY:
10559         case VARYING:
10560         case BFILE:
10561         case BLOB:
10562         case CLOB:
10563         case NCLOB:
10564         case YEAR:
10565         case LOCAL:
10566         case WITH:
10567         case ZONE:
10568         case CHARACTER:
10569         case AFTER:
10570         case BEFORE:
10571         case OLD:
10572         case PARENT:
10573         case CC_IF:
10574         case CC_ERROR:
10575         case ANALYZE:
10576         case ASSOCIATE:
10577         case AUDIT:
10578         case COMPOUND:
10579         case DATABASE:
10580         case CALL:
10581         case DDL:
10582         case DISASSOCIATE:
10583         case EACH:
10584         case FOLLOWS:
10585         case LOGOFF:
10586         case LOGON:
10587         case NESTED:
10588         case NOAUDIT:
10589         case SCHEMA:
10590         case SERVERERROR:
10591         case SHUTDOWN:
10592         case STARTUP:
10593         case STATEMENT:
10594         case STATISTICS:
10595         case SUSPEND:
10596         case TRUNCATE:
10597         case WRAPPED:
10598         case LIBRARY:
10599         case NAME:
10600         case STRUCT:
10601         case CONTEXT:
10602         case PARAMETERS:
10603         case LENGTH:
10604         case TDO:
10605         case MAXLEN:
10606         case CHARSETID:
10607         case CHARSETFORM:
10608         case ACCEPT:
10609         case ACCESSIBLE:
10610         case COPY:
10611         case DEFINE:
10612         case DISCONNECT:
10613         case HOST:
10614         case PRINT:
10615         case QUIT:
10616         case REMARK:
10617         case UNDEFINE:
10618         case VARIABLE:
10619         case WHENEVER:
10620         case ATTACH:
10621         case CAST:
10622         case TREAT:
10623         case TRIM:
10624         case LEFT:
10625         case RIGHT:
10626         case BOTH:
10627         case EMPTY:
10628         case MULTISET:
10629         case SUBMULTISET:
10630         case LEADING:
10631         case TRAILING:
10632         case CHAR_CS:
10633         case NCHAR_CS:
10634         case DBTIMEZONE:
10635         case SESSIONTIMEZONE:
10636         case AUTHENTICATED:
10637         case LINK:
10638         case SHARED:
10639         case DIRECTORY:
10640         case USER:
10641         case IDENTIFIER:
10642         case UNSIGNED_NUMERIC_LITERAL:
10643         case CHARACTER_LITERAL:
10644         case STRING_LITERAL:
10645         case QUOTED_LITERAL:
10646           ;
10647           break;
10648         default:
10649           jj_la1[128] = jj_gen;
10650           break label_26;
10651         }
10652       }
10653         jjtree.closeNodeScope(jjtn000, true);
10654         jjtc000 = false;
10655         {if (true) return jjtn000 ;}
10656     } catch (Throwable jjte000) {
10657           if (jjtc000) {
10658             jjtree.clearNodeScope(jjtn000);
10659             jjtc000 = false;
10660           } else {
10661             jjtree.popNode();
10662           }
10663           if (jjte000 instanceof RuntimeException) {
10664             {if (true) throw (RuntimeException)jjte000;}
10665           }
10666           if (jjte000 instanceof ParseException) {
10667             {if (true) throw (ParseException)jjte000;}
10668           }
10669           {if (true) throw (Error)jjte000;}
10670     } finally {
10671           if (jjtc000) {
10672             jjtree.closeNodeScope(jjtn000, true);
10673           }
10674     }
10675     throw new Error("Missing return statement in function");
10676   }
10677 
10678   final public ASTElseClause ElseClause() throws ParseException {
10679  /*@bgen(jjtree) ElseClause */
10680   ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10681   boolean jjtc000 = true;
10682   jjtree.openNodeScope(jjtn000);
10683     try {
10684       jj_consume_token(ELSE);
10685       label_27:
10686       while (true) {
10687         Statement();
10688         switch (jj_nt.kind) {
10689         case 5:
10690         case 16:
10691         case 17:
10692         case 21:
10693         case REPLACE:
10694         case DEFINER:
10695         case CURRENT_USER:
10696         case LANGUAGE:
10697         case INLINE:
10698         case ADD:
10699         case AGGREGATE:
10700         case ARRAY:
10701         case AT:
10702         case ATTRIBUTE:
10703         case AUTHID:
10704         case BEGIN:
10705         case BODY:
10706         case BULK:
10707         case BYTE:
10708         case CASCADE:
10709         case CASE:
10710         case CLOSE:
10711         case COALESCE:
10712         case COLLECT:
10713         case COLUMN:
10714         case COMMENT:
10715         case COMMIT:
10716         case CONSTRUCTOR:
10717         case CONTINUE:
10718         case CONVERT:
10719         case CURRENT:
10720         case CURSOR:
10721         case DATA:
10722         case DATE:
10723         case DAY:
10724         case DECLARE:
10725         case DELETE:
10726         case DISABLE:
10727         case EDITIONABLE:
10728         case ELEMENT:
10729         case ENABLE:
10730         case ESCAPE:
10731         case EXCEPT:
10732         case EXCEPTIONS:
10733         case EXECUTE:
10734         case EXIT:
10735         case EXTERNAL:
10736         case EXTENDS:
10737         case EXTRACT:
10738         case FALSE:
10739         case FETCH:
10740         case FINAL:
10741         case FOR:
10742         case FORALL:
10743         case FORCE:
10744         case FUNCTION:
10745         case GLOBAL:
10746         case GOTO:
10747         case HASH:
10748         case HEAP:
10749         case HOUR:
10750         case IF:
10751         case IMMEDIATE:
10752         case INDICES:
10753         case INDEXTYPE:
10754         case INDICATOR:
10755         case INSERT:
10756         case INSTANTIABLE:
10757         case INTERVAL:
10758         case INVALIDATE:
10759         case ISOLATION:
10760         case JAVA:
10761         case LEVEL:
10762         case LIMIT:
10763         case LOCK:
10764         case LOOP:
10765         case MAP:
10766         case MAX:
10767         case MEMBER:
10768         case MERGE:
10769         case MIN:
10770         case MINUTE:
10771         case MLSLABEL:
10772         case MODIFY:
10773         case MOD:
10774         case MONTH:
10775         case NATURAL:
10776         case NEW:
10777         case NEW_DOT:
10778         case NO:
10779         case NONEDITIONABLE:
10780         case NOT:
10781         case NULL:
10782         case NULLIF:
10783         case OBJECT:
10784         case OID:
10785         case OPAQUE:
10786         case OPEN:
10787         case OPERATOR:
10788         case ORGANIZATION:
10789         case OTHERS:
10790         case OVERRIDING:
10791         case PACKAGE:
10792         case PARTITION:
10793         case PIPE:
10794         case PRAGMA:
10795         case PRESERVE:
10796         case PRIVATE:
10797         case PROCEDURE:
10798         case RAISE:
10799         case RANGE:
10800         case RAW:
10801         case REAL:
10802         case RECORD:
10803         case REF:
10804         case RELEASE:
10805         case RELIES_ON:
10806         case RENAME:
10807         case RESULT:
10808         case RETURN:
10809         case RETURNING:
10810         case REVERSE:
10811         case ROLLBACK:
10812         case ROW:
10813         case ROWS:
10814         case ROWID:
10815         case ROWNUM:
10816         case SAVE:
10817         case SAVEPOINT:
10818         case SECOND:
10819         case SELECT:
10820         case SELF:
10821         case SET:
10822         case SPACE:
10823         case SQL:
10824         case SQLCODE:
10825         case SQLERRM:
10826         case STATIC:
10827         case SUBTYPE:
10828         case SUBSTITUTABLE:
10829         case SUCCESSFUL:
10830         case SYSDATE:
10831         case SYS_REFCURSOR:
10832         case TEMPORARY:
10833         case TIME:
10834         case TIMESTAMP:
10835         case TIMEZONE_REGION:
10836         case TIMEZONE_ABBR:
10837         case TIMEZONE_MINUTE:
10838         case TIMEZONE_HOUR:
10839         case TRANSACTION:
10840         case TRUE:
10841         case TYPE:
10842         case UNDER:
10843         case USING:
10844         case WHILE:
10845         case YES:
10846         case SHOW:
10847         case A:
10848         case UPDATE:
10849         case DOUBLE:
10850         case DEC:
10851         case PRECISION:
10852         case INT:
10853         case NUMERIC:
10854         case NCHAR:
10855         case NVARCHAR2:
10856         case STRING:
10857         case UROWID:
10858         case VARRAY:
10859         case VARYING:
10860         case BFILE:
10861         case BLOB:
10862         case CLOB:
10863         case NCLOB:
10864         case YEAR:
10865         case LOCAL:
10866         case WITH:
10867         case ZONE:
10868         case CHARACTER:
10869         case AFTER:
10870         case BEFORE:
10871         case OLD:
10872         case PARENT:
10873         case CC_IF:
10874         case CC_ERROR:
10875         case ANALYZE:
10876         case ASSOCIATE:
10877         case AUDIT:
10878         case COMPOUND:
10879         case DATABASE:
10880         case CALL:
10881         case DDL:
10882         case DISASSOCIATE:
10883         case EACH:
10884         case FOLLOWS:
10885         case LOGOFF:
10886         case LOGON:
10887         case NESTED:
10888         case NOAUDIT:
10889         case SCHEMA:
10890         case SERVERERROR:
10891         case SHUTDOWN:
10892         case STARTUP:
10893         case STATEMENT:
10894         case STATISTICS:
10895         case SUSPEND:
10896         case TRUNCATE:
10897         case WRAPPED:
10898         case LIBRARY:
10899         case NAME:
10900         case STRUCT:
10901         case CONTEXT:
10902         case PARAMETERS:
10903         case LENGTH:
10904         case TDO:
10905         case MAXLEN:
10906         case CHARSETID:
10907         case CHARSETFORM:
10908         case ACCEPT:
10909         case ACCESSIBLE:
10910         case COPY:
10911         case DEFINE:
10912         case DISCONNECT:
10913         case HOST:
10914         case PRINT:
10915         case QUIT:
10916         case REMARK:
10917         case UNDEFINE:
10918         case VARIABLE:
10919         case WHENEVER:
10920         case ATTACH:
10921         case CAST:
10922         case TREAT:
10923         case TRIM:
10924         case LEFT:
10925         case RIGHT:
10926         case BOTH:
10927         case EMPTY:
10928         case MULTISET:
10929         case SUBMULTISET:
10930         case LEADING:
10931         case TRAILING:
10932         case CHAR_CS:
10933         case NCHAR_CS:
10934         case DBTIMEZONE:
10935         case SESSIONTIMEZONE:
10936         case AUTHENTICATED:
10937         case LINK:
10938         case SHARED:
10939         case DIRECTORY:
10940         case USER:
10941         case IDENTIFIER:
10942         case UNSIGNED_NUMERIC_LITERAL:
10943         case CHARACTER_LITERAL:
10944         case STRING_LITERAL:
10945         case QUOTED_LITERAL:
10946           ;
10947           break;
10948         default:
10949           jj_la1[129] = jj_gen;
10950           break label_27;
10951         }
10952       }
10953         jjtree.closeNodeScope(jjtn000, true);
10954         jjtc000 = false;
10955         {if (true) return jjtn000 ;}
10956     } catch (Throwable jjte000) {
10957           if (jjtc000) {
10958             jjtree.clearNodeScope(jjtn000);
10959             jjtc000 = false;
10960           } else {
10961             jjtree.popNode();
10962           }
10963           if (jjte000 instanceof RuntimeException) {
10964             {if (true) throw (RuntimeException)jjte000;}
10965           }
10966           if (jjte000 instanceof ParseException) {
10967             {if (true) throw (ParseException)jjte000;}
10968           }
10969           {if (true) throw (Error)jjte000;}
10970     } finally {
10971           if (jjtc000) {
10972             jjtree.closeNodeScope(jjtn000, true);
10973           }
10974     }
10975     throw new Error("Missing return statement in function");
10976   }
10977 
10978   final public ASTElsifClause ElsifClause() throws ParseException {
10979  /*@bgen(jjtree) ElsifClause */
10980   ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10981   boolean jjtc000 = true;
10982   jjtree.openNodeScope(jjtn000);
10983     try {
10984       jj_consume_token(ELSIF);
10985       Expression();
10986       jj_consume_token(THEN);
10987       label_28:
10988       while (true) {
10989         Statement();
10990         switch (jj_nt.kind) {
10991         case 5:
10992         case 16:
10993         case 17:
10994         case 21:
10995         case REPLACE:
10996         case DEFINER:
10997         case CURRENT_USER:
10998         case LANGUAGE:
10999         case INLINE:
11000         case ADD:
11001         case AGGREGATE:
11002         case ARRAY:
11003         case AT:
11004         case ATTRIBUTE:
11005         case AUTHID:
11006         case BEGIN:
11007         case BODY:
11008         case BULK:
11009         case BYTE:
11010         case CASCADE:
11011         case CASE:
11012         case CLOSE:
11013         case COALESCE:
11014         case COLLECT:
11015         case COLUMN:
11016         case COMMENT:
11017         case COMMIT:
11018         case CONSTRUCTOR:
11019         case CONTINUE:
11020         case CONVERT:
11021         case CURRENT:
11022         case CURSOR:
11023         case DATA:
11024         case DATE:
11025         case DAY:
11026         case DECLARE:
11027         case DELETE:
11028         case DISABLE:
11029         case EDITIONABLE:
11030         case ELEMENT:
11031         case ENABLE:
11032         case ESCAPE:
11033         case EXCEPT:
11034         case EXCEPTIONS:
11035         case EXECUTE:
11036         case EXIT:
11037         case EXTERNAL:
11038         case EXTENDS:
11039         case EXTRACT:
11040         case FALSE:
11041         case FETCH:
11042         case FINAL:
11043         case FOR:
11044         case FORALL:
11045         case FORCE:
11046         case FUNCTION:
11047         case GLOBAL:
11048         case GOTO:
11049         case HASH:
11050         case HEAP:
11051         case HOUR:
11052         case IF:
11053         case IMMEDIATE:
11054         case INDICES:
11055         case INDEXTYPE:
11056         case INDICATOR:
11057         case INSERT:
11058         case INSTANTIABLE:
11059         case INTERVAL:
11060         case INVALIDATE:
11061         case ISOLATION:
11062         case JAVA:
11063         case LEVEL:
11064         case LIMIT:
11065         case LOCK:
11066         case LOOP:
11067         case MAP:
11068         case MAX:
11069         case MEMBER:
11070         case MERGE:
11071         case MIN:
11072         case MINUTE:
11073         case MLSLABEL:
11074         case MODIFY:
11075         case MOD:
11076         case MONTH:
11077         case NATURAL:
11078         case NEW:
11079         case NEW_DOT:
11080         case NO:
11081         case NONEDITIONABLE:
11082         case NOT:
11083         case NULL:
11084         case NULLIF:
11085         case OBJECT:
11086         case OID:
11087         case OPAQUE:
11088         case OPEN:
11089         case OPERATOR:
11090         case ORGANIZATION:
11091         case OTHERS:
11092         case OVERRIDING:
11093         case PACKAGE:
11094         case PARTITION:
11095         case PIPE:
11096         case PRAGMA:
11097         case PRESERVE:
11098         case PRIVATE:
11099         case PROCEDURE:
11100         case RAISE:
11101         case RANGE:
11102         case RAW:
11103         case REAL:
11104         case RECORD:
11105         case REF:
11106         case RELEASE:
11107         case RELIES_ON:
11108         case RENAME:
11109         case RESULT:
11110         case RETURN:
11111         case RETURNING:
11112         case REVERSE:
11113         case ROLLBACK:
11114         case ROW:
11115         case ROWS:
11116         case ROWID:
11117         case ROWNUM:
11118         case SAVE:
11119         case SAVEPOINT:
11120         case SECOND:
11121         case SELECT:
11122         case SELF:
11123         case SET:
11124         case SPACE:
11125         case SQL:
11126         case SQLCODE:
11127         case SQLERRM:
11128         case STATIC:
11129         case SUBTYPE:
11130         case SUBSTITUTABLE:
11131         case SUCCESSFUL:
11132         case SYSDATE:
11133         case SYS_REFCURSOR:
11134         case TEMPORARY:
11135         case TIME:
11136         case TIMESTAMP:
11137         case TIMEZONE_REGION:
11138         case TIMEZONE_ABBR:
11139         case TIMEZONE_MINUTE:
11140         case TIMEZONE_HOUR:
11141         case TRANSACTION:
11142         case TRUE:
11143         case TYPE:
11144         case UNDER:
11145         case USING:
11146         case WHILE:
11147         case YES:
11148         case SHOW:
11149         case A:
11150         case UPDATE:
11151         case DOUBLE:
11152         case DEC:
11153         case PRECISION:
11154         case INT:
11155         case NUMERIC:
11156         case NCHAR:
11157         case NVARCHAR2:
11158         case STRING:
11159         case UROWID:
11160         case VARRAY:
11161         case VARYING:
11162         case BFILE:
11163         case BLOB:
11164         case CLOB:
11165         case NCLOB:
11166         case YEAR:
11167         case LOCAL:
11168         case WITH:
11169         case ZONE:
11170         case CHARACTER:
11171         case AFTER:
11172         case BEFORE:
11173         case OLD:
11174         case PARENT:
11175         case CC_IF:
11176         case CC_ERROR:
11177         case ANALYZE:
11178         case ASSOCIATE:
11179         case AUDIT:
11180         case COMPOUND:
11181         case DATABASE:
11182         case CALL:
11183         case DDL:
11184         case DISASSOCIATE:
11185         case EACH:
11186         case FOLLOWS:
11187         case LOGOFF:
11188         case LOGON:
11189         case NESTED:
11190         case NOAUDIT:
11191         case SCHEMA:
11192         case SERVERERROR:
11193         case SHUTDOWN:
11194         case STARTUP:
11195         case STATEMENT:
11196         case STATISTICS:
11197         case SUSPEND:
11198         case TRUNCATE:
11199         case WRAPPED:
11200         case LIBRARY:
11201         case NAME:
11202         case STRUCT:
11203         case CONTEXT:
11204         case PARAMETERS:
11205         case LENGTH:
11206         case TDO:
11207         case MAXLEN:
11208         case CHARSETID:
11209         case CHARSETFORM:
11210         case ACCEPT:
11211         case ACCESSIBLE:
11212         case COPY:
11213         case DEFINE:
11214         case DISCONNECT:
11215         case HOST:
11216         case PRINT:
11217         case QUIT:
11218         case REMARK:
11219         case UNDEFINE:
11220         case VARIABLE:
11221         case WHENEVER:
11222         case ATTACH:
11223         case CAST:
11224         case TREAT:
11225         case TRIM:
11226         case LEFT:
11227         case RIGHT:
11228         case BOTH:
11229         case EMPTY:
11230         case MULTISET:
11231         case SUBMULTISET:
11232         case LEADING:
11233         case TRAILING:
11234         case CHAR_CS:
11235         case NCHAR_CS:
11236         case DBTIMEZONE:
11237         case SESSIONTIMEZONE:
11238         case AUTHENTICATED:
11239         case LINK:
11240         case SHARED:
11241         case DIRECTORY:
11242         case USER:
11243         case IDENTIFIER:
11244         case UNSIGNED_NUMERIC_LITERAL:
11245         case CHARACTER_LITERAL:
11246         case STRING_LITERAL:
11247         case QUOTED_LITERAL:
11248           ;
11249           break;
11250         default:
11251           jj_la1[130] = jj_gen;
11252           break label_28;
11253         }
11254       }
11255         jjtree.closeNodeScope(jjtn000, true);
11256         jjtc000 = false;
11257         {if (true) return jjtn000 ;}
11258     } catch (Throwable jjte000) {
11259         if (jjtc000) {
11260           jjtree.clearNodeScope(jjtn000);
11261           jjtc000 = false;
11262         } else {
11263           jjtree.popNode();
11264         }
11265         if (jjte000 instanceof RuntimeException) {
11266           {if (true) throw (RuntimeException)jjte000;}
11267         }
11268         if (jjte000 instanceof ParseException) {
11269           {if (true) throw (ParseException)jjte000;}
11270         }
11271         {if (true) throw (Error)jjte000;}
11272     } finally {
11273         if (jjtc000) {
11274           jjtree.closeNodeScope(jjtn000, true);
11275         }
11276     }
11277     throw new Error("Missing return statement in function");
11278   }
11279 
11280   final public ASTLoopStatement LoopStatement() throws ParseException {
11281  /*@bgen(jjtree) LoopStatement */
11282   ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11283   boolean jjtc000 = true;
11284   jjtree.openNodeScope(jjtn000);
11285     try {
11286       jj_consume_token(LOOP);
11287       label_29:
11288       while (true) {
11289         Statement();
11290         switch (jj_nt.kind) {
11291         case 5:
11292         case 16:
11293         case 17:
11294         case 21:
11295         case REPLACE:
11296         case DEFINER:
11297         case CURRENT_USER:
11298         case LANGUAGE:
11299         case INLINE:
11300         case ADD:
11301         case AGGREGATE:
11302         case ARRAY:
11303         case AT:
11304         case ATTRIBUTE:
11305         case AUTHID:
11306         case BEGIN:
11307         case BODY:
11308         case BULK:
11309         case BYTE:
11310         case CASCADE:
11311         case CASE:
11312         case CLOSE:
11313         case COALESCE:
11314         case COLLECT:
11315         case COLUMN:
11316         case COMMENT:
11317         case COMMIT:
11318         case CONSTRUCTOR:
11319         case CONTINUE:
11320         case CONVERT:
11321         case CURRENT:
11322         case CURSOR:
11323         case DATA:
11324         case DATE:
11325         case DAY:
11326         case DECLARE:
11327         case DELETE:
11328         case DISABLE:
11329         case EDITIONABLE:
11330         case ELEMENT:
11331         case ENABLE:
11332         case ESCAPE:
11333         case EXCEPT:
11334         case EXCEPTIONS:
11335         case EXECUTE:
11336         case EXIT:
11337         case EXTERNAL:
11338         case EXTENDS:
11339         case EXTRACT:
11340         case FALSE:
11341         case FETCH:
11342         case FINAL:
11343         case FOR:
11344         case FORALL:
11345         case FORCE:
11346         case FUNCTION:
11347         case GLOBAL:
11348         case GOTO:
11349         case HASH:
11350         case HEAP:
11351         case HOUR:
11352         case IF:
11353         case IMMEDIATE:
11354         case INDICES:
11355         case INDEXTYPE:
11356         case INDICATOR:
11357         case INSERT:
11358         case INSTANTIABLE:
11359         case INTERVAL:
11360         case INVALIDATE:
11361         case ISOLATION:
11362         case JAVA:
11363         case LEVEL:
11364         case LIMIT:
11365         case LOCK:
11366         case LOOP:
11367         case MAP:
11368         case MAX:
11369         case MEMBER:
11370         case MERGE:
11371         case MIN:
11372         case MINUTE:
11373         case MLSLABEL:
11374         case MODIFY:
11375         case MOD:
11376         case MONTH:
11377         case NATURAL:
11378         case NEW:
11379         case NEW_DOT:
11380         case NO:
11381         case NONEDITIONABLE:
11382         case NOT:
11383         case NULL:
11384         case NULLIF:
11385         case OBJECT:
11386         case OID:
11387         case OPAQUE:
11388         case OPEN:
11389         case OPERATOR:
11390         case ORGANIZATION:
11391         case OTHERS:
11392         case OVERRIDING:
11393         case PACKAGE:
11394         case PARTITION:
11395         case PIPE:
11396         case PRAGMA:
11397         case PRESERVE:
11398         case PRIVATE:
11399         case PROCEDURE:
11400         case RAISE:
11401         case RANGE:
11402         case RAW:
11403         case REAL:
11404         case RECORD:
11405         case REF:
11406         case RELEASE:
11407         case RELIES_ON:
11408         case RENAME:
11409         case RESULT:
11410         case RETURN:
11411         case RETURNING:
11412         case REVERSE:
11413         case ROLLBACK:
11414         case ROW:
11415         case ROWS:
11416         case ROWID:
11417         case ROWNUM:
11418         case SAVE:
11419         case SAVEPOINT:
11420         case SECOND:
11421         case SELECT:
11422         case SELF:
11423         case SET:
11424         case SPACE:
11425         case SQL:
11426         case SQLCODE:
11427         case SQLERRM:
11428         case STATIC:
11429         case SUBTYPE:
11430         case SUBSTITUTABLE:
11431         case SUCCESSFUL:
11432         case SYSDATE:
11433         case SYS_REFCURSOR:
11434         case TEMPORARY:
11435         case TIME:
11436         case TIMESTAMP:
11437         case TIMEZONE_REGION:
11438         case TIMEZONE_ABBR:
11439         case TIMEZONE_MINUTE:
11440         case TIMEZONE_HOUR:
11441         case TRANSACTION:
11442         case TRUE:
11443         case TYPE:
11444         case UNDER:
11445         case USING:
11446         case WHILE:
11447         case YES:
11448         case SHOW:
11449         case A:
11450         case UPDATE:
11451         case DOUBLE:
11452         case DEC:
11453         case PRECISION:
11454         case INT:
11455         case NUMERIC:
11456         case NCHAR:
11457         case NVARCHAR2:
11458         case STRING:
11459         case UROWID:
11460         case VARRAY:
11461         case VARYING:
11462         case BFILE:
11463         case BLOB:
11464         case CLOB:
11465         case NCLOB:
11466         case YEAR:
11467         case LOCAL:
11468         case WITH:
11469         case ZONE:
11470         case CHARACTER:
11471         case AFTER:
11472         case BEFORE:
11473         case OLD:
11474         case PARENT:
11475         case CC_IF:
11476         case CC_ERROR:
11477         case ANALYZE:
11478         case ASSOCIATE:
11479         case AUDIT:
11480         case COMPOUND:
11481         case DATABASE:
11482         case CALL:
11483         case DDL:
11484         case DISASSOCIATE:
11485         case EACH:
11486         case FOLLOWS:
11487         case LOGOFF:
11488         case LOGON:
11489         case NESTED:
11490         case NOAUDIT:
11491         case SCHEMA:
11492         case SERVERERROR:
11493         case SHUTDOWN:
11494         case STARTUP:
11495         case STATEMENT:
11496         case STATISTICS:
11497         case SUSPEND:
11498         case TRUNCATE:
11499         case WRAPPED:
11500         case LIBRARY:
11501         case NAME:
11502         case STRUCT:
11503         case CONTEXT:
11504         case PARAMETERS:
11505         case LENGTH:
11506         case TDO:
11507         case MAXLEN:
11508         case CHARSETID:
11509         case CHARSETFORM:
11510         case ACCEPT:
11511         case ACCESSIBLE:
11512         case COPY:
11513         case DEFINE:
11514         case DISCONNECT:
11515         case HOST:
11516         case PRINT:
11517         case QUIT:
11518         case REMARK:
11519         case UNDEFINE:
11520         case VARIABLE:
11521         case WHENEVER:
11522         case ATTACH:
11523         case CAST:
11524         case TREAT:
11525         case TRIM:
11526         case LEFT:
11527         case RIGHT:
11528         case BOTH:
11529         case EMPTY:
11530         case MULTISET:
11531         case SUBMULTISET:
11532         case LEADING:
11533         case TRAILING:
11534         case CHAR_CS:
11535         case NCHAR_CS:
11536         case DBTIMEZONE:
11537         case SESSIONTIMEZONE:
11538         case AUTHENTICATED:
11539         case LINK:
11540         case SHARED:
11541         case DIRECTORY:
11542         case USER:
11543         case IDENTIFIER:
11544         case UNSIGNED_NUMERIC_LITERAL:
11545         case CHARACTER_LITERAL:
11546         case STRING_LITERAL:
11547         case QUOTED_LITERAL:
11548           ;
11549           break;
11550         default:
11551           jj_la1[131] = jj_gen;
11552           break label_29;
11553         }
11554       }
11555       jj_consume_token(END);
11556       jj_consume_token(LOOP);
11557       switch (jj_nt.kind) {
11558       case IDENTIFIER:
11559         jj_consume_token(IDENTIFIER);
11560         break;
11561       default:
11562         jj_la1[132] = jj_gen;
11563         ;
11564       }
11565         jjtree.closeNodeScope(jjtn000, true);
11566         jjtc000 = false;
11567         {if (true) return jjtn000 ;}
11568     } catch (Throwable jjte000) {
11569          if (jjtc000) {
11570            jjtree.clearNodeScope(jjtn000);
11571            jjtc000 = false;
11572          } else {
11573            jjtree.popNode();
11574          }
11575          if (jjte000 instanceof RuntimeException) {
11576            {if (true) throw (RuntimeException)jjte000;}
11577          }
11578          if (jjte000 instanceof ParseException) {
11579            {if (true) throw (ParseException)jjte000;}
11580          }
11581          {if (true) throw (Error)jjte000;}
11582     } finally {
11583          if (jjtc000) {
11584            jjtree.closeNodeScope(jjtn000, true);
11585          }
11586     }
11587     throw new Error("Missing return statement in function");
11588   }
11589 
11590 /** Scope rule: the loop index only exists within the Loop */
11591   final public ASTForStatement ForStatement() throws ParseException {
11592  /*@bgen(jjtree) ForStatement */
11593   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11594   boolean jjtc000 = true;
11595   jjtree.openNodeScope(jjtn000);
11596     try {
11597       jj_consume_token(FOR);
11598       ForIndex();
11599       jj_consume_token(IN);
11600       switch (jj_nt.kind) {
11601       case REVERSE:
11602         jj_consume_token(REVERSE);
11603         break;
11604       default:
11605         jj_la1[133] = jj_gen;
11606         ;
11607       }
11608       Expression();
11609       switch (jj_nt.kind) {
11610       case 12:
11611         jj_consume_token(12);
11612         Expression();
11613         break;
11614       default:
11615         jj_la1[134] = jj_gen;
11616         ;
11617       }
11618       jj_consume_token(LOOP);
11619       label_30:
11620       while (true) {
11621         Statement();
11622         switch (jj_nt.kind) {
11623         case 5:
11624         case 16:
11625         case 17:
11626         case 21:
11627         case REPLACE:
11628         case DEFINER:
11629         case CURRENT_USER:
11630         case LANGUAGE:
11631         case INLINE:
11632         case ADD:
11633         case AGGREGATE:
11634         case ARRAY:
11635         case AT:
11636         case ATTRIBUTE:
11637         case AUTHID:
11638         case BEGIN:
11639         case BODY:
11640         case BULK:
11641         case BYTE:
11642         case CASCADE:
11643         case CASE:
11644         case CLOSE:
11645         case COALESCE:
11646         case COLLECT:
11647         case COLUMN:
11648         case COMMENT:
11649         case COMMIT:
11650         case CONSTRUCTOR:
11651         case CONTINUE:
11652         case CONVERT:
11653         case CURRENT:
11654         case CURSOR:
11655         case DATA:
11656         case DATE:
11657         case DAY:
11658         case DECLARE:
11659         case DELETE:
11660         case DISABLE:
11661         case EDITIONABLE:
11662         case ELEMENT:
11663         case ENABLE:
11664         case ESCAPE:
11665         case EXCEPT:
11666         case EXCEPTIONS:
11667         case EXECUTE:
11668         case EXIT:
11669         case EXTERNAL:
11670         case EXTENDS:
11671         case EXTRACT:
11672         case FALSE:
11673         case FETCH:
11674         case FINAL:
11675         case FOR:
11676         case FORALL:
11677         case FORCE:
11678         case FUNCTION:
11679         case GLOBAL:
11680         case GOTO:
11681         case HASH:
11682         case HEAP:
11683         case HOUR:
11684         case IF:
11685         case IMMEDIATE:
11686         case INDICES:
11687         case INDEXTYPE:
11688         case INDICATOR:
11689         case INSERT:
11690         case INSTANTIABLE:
11691         case INTERVAL:
11692         case INVALIDATE:
11693         case ISOLATION:
11694         case JAVA:
11695         case LEVEL:
11696         case LIMIT:
11697         case LOCK:
11698         case LOOP:
11699         case MAP:
11700         case MAX:
11701         case MEMBER:
11702         case MERGE:
11703         case MIN:
11704         case MINUTE:
11705         case MLSLABEL:
11706         case MODIFY:
11707         case MOD:
11708         case MONTH:
11709         case NATURAL:
11710         case NEW:
11711         case NEW_DOT:
11712         case NO:
11713         case NONEDITIONABLE:
11714         case NOT:
11715         case NULL:
11716         case NULLIF:
11717         case OBJECT:
11718         case OID:
11719         case OPAQUE:
11720         case OPEN:
11721         case OPERATOR:
11722         case ORGANIZATION:
11723         case OTHERS:
11724         case OVERRIDING:
11725         case PACKAGE:
11726         case PARTITION:
11727         case PIPE:
11728         case PRAGMA:
11729         case PRESERVE:
11730         case PRIVATE:
11731         case PROCEDURE:
11732         case RAISE:
11733         case RANGE:
11734         case RAW:
11735         case REAL:
11736         case RECORD:
11737         case REF:
11738         case RELEASE:
11739         case RELIES_ON:
11740         case RENAME:
11741         case RESULT:
11742         case RETURN:
11743         case RETURNING:
11744         case REVERSE:
11745         case ROLLBACK:
11746         case ROW:
11747         case ROWS:
11748         case ROWID:
11749         case ROWNUM:
11750         case SAVE:
11751         case SAVEPOINT:
11752         case SECOND:
11753         case SELECT:
11754         case SELF:
11755         case SET:
11756         case SPACE:
11757         case SQL:
11758         case SQLCODE:
11759         case SQLERRM:
11760         case STATIC:
11761         case SUBTYPE:
11762         case SUBSTITUTABLE:
11763         case SUCCESSFUL:
11764         case SYSDATE:
11765         case SYS_REFCURSOR:
11766         case TEMPORARY:
11767         case TIME:
11768         case TIMESTAMP:
11769         case TIMEZONE_REGION:
11770         case TIMEZONE_ABBR:
11771         case TIMEZONE_MINUTE:
11772         case TIMEZONE_HOUR:
11773         case TRANSACTION:
11774         case TRUE:
11775         case TYPE:
11776         case UNDER:
11777         case USING:
11778         case WHILE:
11779         case YES:
11780         case SHOW:
11781         case A:
11782         case UPDATE:
11783         case DOUBLE:
11784         case DEC:
11785         case PRECISION:
11786         case INT:
11787         case NUMERIC:
11788         case NCHAR:
11789         case NVARCHAR2:
11790         case STRING:
11791         case UROWID:
11792         case VARRAY:
11793         case VARYING:
11794         case BFILE:
11795         case BLOB:
11796         case CLOB:
11797         case NCLOB:
11798         case YEAR:
11799         case LOCAL:
11800         case WITH:
11801         case ZONE:
11802         case CHARACTER:
11803         case AFTER:
11804         case BEFORE:
11805         case OLD:
11806         case PARENT:
11807         case CC_IF:
11808         case CC_ERROR:
11809         case ANALYZE:
11810         case ASSOCIATE:
11811         case AUDIT:
11812         case COMPOUND:
11813         case DATABASE:
11814         case CALL:
11815         case DDL:
11816         case DISASSOCIATE:
11817         case EACH:
11818         case FOLLOWS:
11819         case LOGOFF:
11820         case LOGON:
11821         case NESTED:
11822         case NOAUDIT:
11823         case SCHEMA:
11824         case SERVERERROR:
11825         case SHUTDOWN:
11826         case STARTUP:
11827         case STATEMENT:
11828         case STATISTICS:
11829         case SUSPEND:
11830         case TRUNCATE:
11831         case WRAPPED:
11832         case LIBRARY:
11833         case NAME:
11834         case STRUCT:
11835         case CONTEXT:
11836         case PARAMETERS:
11837         case LENGTH:
11838         case TDO:
11839         case MAXLEN:
11840         case CHARSETID:
11841         case CHARSETFORM:
11842         case ACCEPT:
11843         case ACCESSIBLE:
11844         case COPY:
11845         case DEFINE:
11846         case DISCONNECT:
11847         case HOST:
11848         case PRINT:
11849         case QUIT:
11850         case REMARK:
11851         case UNDEFINE:
11852         case VARIABLE:
11853         case WHENEVER:
11854         case ATTACH:
11855         case CAST:
11856         case TREAT:
11857         case TRIM:
11858         case LEFT:
11859         case RIGHT:
11860         case BOTH:
11861         case EMPTY:
11862         case MULTISET:
11863         case SUBMULTISET:
11864         case LEADING:
11865         case TRAILING:
11866         case CHAR_CS:
11867         case NCHAR_CS:
11868         case DBTIMEZONE:
11869         case SESSIONTIMEZONE:
11870         case AUTHENTICATED:
11871         case LINK:
11872         case SHARED:
11873         case DIRECTORY:
11874         case USER:
11875         case IDENTIFIER:
11876         case UNSIGNED_NUMERIC_LITERAL:
11877         case CHARACTER_LITERAL:
11878         case STRING_LITERAL:
11879         case QUOTED_LITERAL:
11880           ;
11881           break;
11882         default:
11883           jj_la1[135] = jj_gen;
11884           break label_30;
11885         }
11886       }
11887       jj_consume_token(END);
11888       jj_consume_token(LOOP);
11889       switch (jj_nt.kind) {
11890       case IDENTIFIER:
11891         jj_consume_token(IDENTIFIER);
11892         break;
11893       default:
11894         jj_la1[136] = jj_gen;
11895         ;
11896       }
11897         jjtree.closeNodeScope(jjtn000, true);
11898         jjtc000 = false;
11899         {if (true) return jjtn000 ;}
11900     } catch (Throwable jjte000) {
11901            if (jjtc000) {
11902              jjtree.clearNodeScope(jjtn000);
11903              jjtc000 = false;
11904            } else {
11905              jjtree.popNode();
11906            }
11907            if (jjte000 instanceof RuntimeException) {
11908              {if (true) throw (RuntimeException)jjte000;}
11909            }
11910            if (jjte000 instanceof ParseException) {
11911              {if (true) throw (ParseException)jjte000;}
11912            }
11913            {if (true) throw (Error)jjte000;}
11914     } finally {
11915            if (jjtc000) {
11916              jjtree.closeNodeScope(jjtn000, true);
11917            }
11918     }
11919     throw new Error("Missing return statement in function");
11920   }
11921 
11922   final public ASTWhileStatement WhileStatement() throws ParseException {
11923  /*@bgen(jjtree) WhileStatement */
11924   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11925   boolean jjtc000 = true;
11926   jjtree.openNodeScope(jjtn000);
11927     try {
11928       jj_consume_token(WHILE);
11929       Expression();
11930       jj_consume_token(LOOP);
11931       label_31:
11932       while (true) {
11933         Statement();
11934         switch (jj_nt.kind) {
11935         case 5:
11936         case 16:
11937         case 17:
11938         case 21:
11939         case REPLACE:
11940         case DEFINER:
11941         case CURRENT_USER:
11942         case LANGUAGE:
11943         case INLINE:
11944         case ADD:
11945         case AGGREGATE:
11946         case ARRAY:
11947         case AT:
11948         case ATTRIBUTE:
11949         case AUTHID:
11950         case BEGIN:
11951         case BODY:
11952         case BULK:
11953         case BYTE:
11954         case CASCADE:
11955         case CASE:
11956         case CLOSE:
11957         case COALESCE:
11958         case COLLECT:
11959         case COLUMN:
11960         case COMMENT:
11961         case COMMIT:
11962         case CONSTRUCTOR:
11963         case CONTINUE:
11964         case CONVERT:
11965         case CURRENT:
11966         case CURSOR:
11967         case DATA:
11968         case DATE:
11969         case DAY:
11970         case DECLARE:
11971         case DELETE:
11972         case DISABLE:
11973         case EDITIONABLE:
11974         case ELEMENT:
11975         case ENABLE:
11976         case ESCAPE:
11977         case EXCEPT:
11978         case EXCEPTIONS:
11979         case EXECUTE:
11980         case EXIT:
11981         case EXTERNAL:
11982         case EXTENDS:
11983         case EXTRACT:
11984         case FALSE:
11985         case FETCH:
11986         case FINAL:
11987         case FOR:
11988         case FORALL:
11989         case FORCE:
11990         case FUNCTION:
11991         case GLOBAL:
11992         case GOTO:
11993         case HASH:
11994         case HEAP:
11995         case HOUR:
11996         case IF:
11997         case IMMEDIATE:
11998         case INDICES:
11999         case INDEXTYPE:
12000         case INDICATOR:
12001         case INSERT:
12002         case INSTANTIABLE:
12003         case INTERVAL:
12004         case INVALIDATE:
12005         case ISOLATION:
12006         case JAVA:
12007         case LEVEL:
12008         case LIMIT:
12009         case LOCK:
12010         case LOOP:
12011         case MAP:
12012         case MAX:
12013         case MEMBER:
12014         case MERGE:
12015         case MIN:
12016         case MINUTE:
12017         case MLSLABEL:
12018         case MODIFY:
12019         case MOD:
12020         case MONTH:
12021         case NATURAL:
12022         case NEW:
12023         case NEW_DOT:
12024         case NO:
12025         case NONEDITIONABLE:
12026         case NOT:
12027         case NULL:
12028         case NULLIF:
12029         case OBJECT:
12030         case OID:
12031         case OPAQUE:
12032         case OPEN:
12033         case OPERATOR:
12034         case ORGANIZATION:
12035         case OTHERS:
12036         case OVERRIDING:
12037         case PACKAGE:
12038         case PARTITION:
12039         case PIPE:
12040         case PRAGMA:
12041         case PRESERVE:
12042         case PRIVATE:
12043         case PROCEDURE:
12044         case RAISE:
12045         case RANGE:
12046         case RAW:
12047         case REAL:
12048         case RECORD:
12049         case REF:
12050         case RELEASE:
12051         case RELIES_ON:
12052         case RENAME:
12053         case RESULT:
12054         case RETURN:
12055         case RETURNING:
12056         case REVERSE:
12057         case ROLLBACK:
12058         case ROW:
12059         case ROWS:
12060         case ROWID:
12061         case ROWNUM:
12062         case SAVE:
12063         case SAVEPOINT:
12064         case SECOND:
12065         case SELECT:
12066         case SELF:
12067         case SET:
12068         case SPACE:
12069         case SQL:
12070         case SQLCODE:
12071         case SQLERRM:
12072         case STATIC:
12073         case SUBTYPE:
12074         case SUBSTITUTABLE:
12075         case SUCCESSFUL:
12076         case SYSDATE:
12077         case SYS_REFCURSOR:
12078         case TEMPORARY:
12079         case TIME:
12080         case TIMESTAMP:
12081         case TIMEZONE_REGION:
12082         case TIMEZONE_ABBR:
12083         case TIMEZONE_MINUTE:
12084         case TIMEZONE_HOUR:
12085         case TRANSACTION:
12086         case TRUE:
12087         case TYPE:
12088         case UNDER:
12089         case USING:
12090         case WHILE:
12091         case YES:
12092         case SHOW:
12093         case A:
12094         case UPDATE:
12095         case DOUBLE:
12096         case DEC:
12097         case PRECISION:
12098         case INT:
12099         case NUMERIC:
12100         case NCHAR:
12101         case NVARCHAR2:
12102         case STRING:
12103         case UROWID:
12104         case VARRAY:
12105         case VARYING:
12106         case BFILE:
12107         case BLOB:
12108         case CLOB:
12109         case NCLOB:
12110         case YEAR:
12111         case LOCAL:
12112         case WITH:
12113         case ZONE:
12114         case CHARACTER:
12115         case AFTER:
12116         case BEFORE:
12117         case OLD:
12118         case PARENT:
12119         case CC_IF:
12120         case CC_ERROR:
12121         case ANALYZE:
12122         case ASSOCIATE:
12123         case AUDIT:
12124         case COMPOUND:
12125         case DATABASE:
12126         case CALL:
12127         case DDL:
12128         case DISASSOCIATE:
12129         case EACH:
12130         case FOLLOWS:
12131         case LOGOFF:
12132         case LOGON:
12133         case NESTED:
12134         case NOAUDIT:
12135         case SCHEMA:
12136         case SERVERERROR:
12137         case SHUTDOWN:
12138         case STARTUP:
12139         case STATEMENT:
12140         case STATISTICS:
12141         case SUSPEND:
12142         case TRUNCATE:
12143         case WRAPPED:
12144         case LIBRARY:
12145         case NAME:
12146         case STRUCT:
12147         case CONTEXT:
12148         case PARAMETERS:
12149         case LENGTH:
12150         case TDO:
12151         case MAXLEN:
12152         case CHARSETID:
12153         case CHARSETFORM:
12154         case ACCEPT:
12155         case ACCESSIBLE:
12156         case COPY:
12157         case DEFINE:
12158         case DISCONNECT:
12159         case HOST:
12160         case PRINT:
12161         case QUIT:
12162         case REMARK:
12163         case UNDEFINE:
12164         case VARIABLE:
12165         case WHENEVER:
12166         case ATTACH:
12167         case CAST:
12168         case TREAT:
12169         case TRIM:
12170         case LEFT:
12171         case RIGHT:
12172         case BOTH:
12173         case EMPTY:
12174         case MULTISET:
12175         case SUBMULTISET:
12176         case LEADING:
12177         case TRAILING:
12178         case CHAR_CS:
12179         case NCHAR_CS:
12180         case DBTIMEZONE:
12181         case SESSIONTIMEZONE:
12182         case AUTHENTICATED:
12183         case LINK:
12184         case SHARED:
12185         case DIRECTORY:
12186         case USER:
12187         case IDENTIFIER:
12188         case UNSIGNED_NUMERIC_LITERAL:
12189         case CHARACTER_LITERAL:
12190         case STRING_LITERAL:
12191         case QUOTED_LITERAL:
12192           ;
12193           break;
12194         default:
12195           jj_la1[137] = jj_gen;
12196           break label_31;
12197         }
12198       }
12199       jj_consume_token(END);
12200       jj_consume_token(LOOP);
12201       switch (jj_nt.kind) {
12202       case IDENTIFIER:
12203         jj_consume_token(IDENTIFIER);
12204         break;
12205       default:
12206         jj_la1[138] = jj_gen;
12207         ;
12208       }
12209         jjtree.closeNodeScope(jjtn000, true);
12210         jjtc000 = false;
12211         {if (true) return jjtn000 ;}
12212     } catch (Throwable jjte000) {
12213            if (jjtc000) {
12214              jjtree.clearNodeScope(jjtn000);
12215              jjtc000 = false;
12216            } else {
12217              jjtree.popNode();
12218            }
12219            if (jjte000 instanceof RuntimeException) {
12220              {if (true) throw (RuntimeException)jjte000;}
12221            }
12222            if (jjte000 instanceof ParseException) {
12223              {if (true) throw (ParseException)jjte000;}
12224            }
12225            {if (true) throw (Error)jjte000;}
12226     } finally {
12227            if (jjtc000) {
12228              jjtree.closeNodeScope(jjtn000, true);
12229            }
12230     }
12231     throw new Error("Missing return statement in function");
12232   }
12233 
12234   final public ASTIfStatement IfStatement() throws ParseException {
12235  /*@bgen(jjtree) IfStatement */
12236   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12237   boolean jjtc000 = true;
12238   jjtree.openNodeScope(jjtn000);
12239     try {
12240       jj_consume_token(IF);
12241       Expression();
12242       jj_consume_token(THEN);
12243       label_32:
12244       while (true) {
12245         Statement();
12246         switch (jj_nt.kind) {
12247         case 5:
12248         case 16:
12249         case 17:
12250         case 21:
12251         case REPLACE:
12252         case DEFINER:
12253         case CURRENT_USER:
12254         case LANGUAGE:
12255         case INLINE:
12256         case ADD:
12257         case AGGREGATE:
12258         case ARRAY:
12259         case AT:
12260         case ATTRIBUTE:
12261         case AUTHID:
12262         case BEGIN:
12263         case BODY:
12264         case BULK:
12265         case BYTE:
12266         case CASCADE:
12267         case CASE:
12268         case CLOSE:
12269         case COALESCE:
12270         case COLLECT:
12271         case COLUMN:
12272         case COMMENT:
12273         case COMMIT:
12274         case CONSTRUCTOR:
12275         case CONTINUE:
12276         case CONVERT:
12277         case CURRENT:
12278         case CURSOR:
12279         case DATA:
12280         case DATE:
12281         case DAY:
12282         case DECLARE:
12283         case DELETE:
12284         case DISABLE:
12285         case EDITIONABLE:
12286         case ELEMENT:
12287         case ENABLE:
12288         case ESCAPE:
12289         case EXCEPT:
12290         case EXCEPTIONS:
12291         case EXECUTE:
12292         case EXIT:
12293         case EXTERNAL:
12294         case EXTENDS:
12295         case EXTRACT:
12296         case FALSE:
12297         case FETCH:
12298         case FINAL:
12299         case FOR:
12300         case FORALL:
12301         case FORCE:
12302         case FUNCTION:
12303         case GLOBAL:
12304         case GOTO:
12305         case HASH:
12306         case HEAP:
12307         case HOUR:
12308         case IF:
12309         case IMMEDIATE:
12310         case INDICES:
12311         case INDEXTYPE:
12312         case INDICATOR:
12313         case INSERT:
12314         case INSTANTIABLE:
12315         case INTERVAL:
12316         case INVALIDATE:
12317         case ISOLATION:
12318         case JAVA:
12319         case LEVEL:
12320         case LIMIT:
12321         case LOCK:
12322         case LOOP:
12323         case MAP:
12324         case MAX:
12325         case MEMBER:
12326         case MERGE:
12327         case MIN:
12328         case MINUTE:
12329         case MLSLABEL:
12330         case MODIFY:
12331         case MOD:
12332         case MONTH:
12333         case NATURAL:
12334         case NEW:
12335         case NEW_DOT:
12336         case NO:
12337         case NONEDITIONABLE:
12338         case NOT:
12339         case NULL:
12340         case NULLIF:
12341         case OBJECT:
12342         case OID:
12343         case OPAQUE:
12344         case OPEN:
12345         case OPERATOR:
12346         case ORGANIZATION:
12347         case OTHERS:
12348         case OVERRIDING:
12349         case PACKAGE:
12350         case PARTITION:
12351         case PIPE:
12352         case PRAGMA:
12353         case PRESERVE:
12354         case PRIVATE:
12355         case PROCEDURE:
12356         case RAISE:
12357         case RANGE:
12358         case RAW:
12359         case REAL:
12360         case RECORD:
12361         case REF:
12362         case RELEASE:
12363         case RELIES_ON:
12364         case RENAME:
12365         case RESULT:
12366         case RETURN:
12367         case RETURNING:
12368         case REVERSE:
12369         case ROLLBACK:
12370         case ROW:
12371         case ROWS:
12372         case ROWID:
12373         case ROWNUM:
12374         case SAVE:
12375         case SAVEPOINT:
12376         case SECOND:
12377         case SELECT:
12378         case SELF:
12379         case SET:
12380         case SPACE:
12381         case SQL:
12382         case SQLCODE:
12383         case SQLERRM:
12384         case STATIC:
12385         case SUBTYPE:
12386         case SUBSTITUTABLE:
12387         case SUCCESSFUL:
12388         case SYSDATE:
12389         case SYS_REFCURSOR:
12390         case TEMPORARY:
12391         case TIME:
12392         case TIMESTAMP:
12393         case TIMEZONE_REGION:
12394         case TIMEZONE_ABBR:
12395         case TIMEZONE_MINUTE:
12396         case TIMEZONE_HOUR:
12397         case TRANSACTION:
12398         case TRUE:
12399         case TYPE:
12400         case UNDER:
12401         case USING:
12402         case WHILE:
12403         case YES:
12404         case SHOW:
12405         case A:
12406         case UPDATE:
12407         case DOUBLE:
12408         case DEC:
12409         case PRECISION:
12410         case INT:
12411         case NUMERIC:
12412         case NCHAR:
12413         case NVARCHAR2:
12414         case STRING:
12415         case UROWID:
12416         case VARRAY:
12417         case VARYING:
12418         case BFILE:
12419         case BLOB:
12420         case CLOB:
12421         case NCLOB:
12422         case YEAR:
12423         case LOCAL:
12424         case WITH:
12425         case ZONE:
12426         case CHARACTER:
12427         case AFTER:
12428         case BEFORE:
12429         case OLD:
12430         case PARENT:
12431         case CC_IF:
12432         case CC_ERROR:
12433         case ANALYZE:
12434         case ASSOCIATE:
12435         case AUDIT:
12436         case COMPOUND:
12437         case DATABASE:
12438         case CALL:
12439         case DDL:
12440         case DISASSOCIATE:
12441         case EACH:
12442         case FOLLOWS:
12443         case LOGOFF:
12444         case LOGON:
12445         case NESTED:
12446         case NOAUDIT:
12447         case SCHEMA:
12448         case SERVERERROR:
12449         case SHUTDOWN:
12450         case STARTUP:
12451         case STATEMENT:
12452         case STATISTICS:
12453         case SUSPEND:
12454         case TRUNCATE:
12455         case WRAPPED:
12456         case LIBRARY:
12457         case NAME:
12458         case STRUCT:
12459         case CONTEXT:
12460         case PARAMETERS:
12461         case LENGTH:
12462         case TDO:
12463         case MAXLEN:
12464         case CHARSETID:
12465         case CHARSETFORM:
12466         case ACCEPT:
12467         case ACCESSIBLE:
12468         case COPY:
12469         case DEFINE:
12470         case DISCONNECT:
12471         case HOST:
12472         case PRINT:
12473         case QUIT:
12474         case REMARK:
12475         case UNDEFINE:
12476         case VARIABLE:
12477         case WHENEVER:
12478         case ATTACH:
12479         case CAST:
12480         case TREAT:
12481         case TRIM:
12482         case LEFT:
12483         case RIGHT:
12484         case BOTH:
12485         case EMPTY:
12486         case MULTISET:
12487         case SUBMULTISET:
12488         case LEADING:
12489         case TRAILING:
12490         case CHAR_CS:
12491         case NCHAR_CS:
12492         case DBTIMEZONE:
12493         case SESSIONTIMEZONE:
12494         case AUTHENTICATED:
12495         case LINK:
12496         case SHARED:
12497         case DIRECTORY:
12498         case USER:
12499         case IDENTIFIER:
12500         case UNSIGNED_NUMERIC_LITERAL:
12501         case CHARACTER_LITERAL:
12502         case STRING_LITERAL:
12503         case QUOTED_LITERAL:
12504           ;
12505           break;
12506         default:
12507           jj_la1[139] = jj_gen;
12508           break label_32;
12509         }
12510       }
12511       label_33:
12512       while (true) {
12513         switch (jj_nt.kind) {
12514         case ELSIF:
12515           ;
12516           break;
12517         default:
12518           jj_la1[140] = jj_gen;
12519           break label_33;
12520         }
12521         ElsifClause();
12522                          jjtn000.setHasElse();
12523       }
12524       switch (jj_nt.kind) {
12525       case ELSE:
12526         ElseClause();
12527                         jjtn000.setHasElse();
12528         break;
12529       default:
12530         jj_la1[141] = jj_gen;
12531         ;
12532       }
12533       jj_consume_token(END);
12534       jj_consume_token(IF);
12535         jjtree.closeNodeScope(jjtn000, true);
12536         jjtc000 = false;
12537         {if (true) return jjtn000 ;}
12538     } catch (Throwable jjte000) {
12539           if (jjtc000) {
12540             jjtree.clearNodeScope(jjtn000);
12541             jjtc000 = false;
12542           } else {
12543             jjtree.popNode();
12544           }
12545           if (jjte000 instanceof RuntimeException) {
12546             {if (true) throw (RuntimeException)jjte000;}
12547           }
12548           if (jjte000 instanceof ParseException) {
12549             {if (true) throw (ParseException)jjte000;}
12550           }
12551           {if (true) throw (Error)jjte000;}
12552     } finally {
12553           if (jjtc000) {
12554             jjtree.closeNodeScope(jjtn000, true);
12555           }
12556     }
12557     throw new Error("Missing return statement in function");
12558   }
12559 
12560 /** Scope rule: the loop index only exists within the statement */
12561 /**
12562 ForIndex is declared implicitly, unlike most variables or constants.
12563 */
12564   final public ASTForIndex ForIndex() throws ParseException {
12565  /*@bgen(jjtree) ForIndex */
12566  ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12567  boolean jjtc000 = true;
12568  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12569     try {
12570       simpleNode = ID();
12571    jjtree.closeNodeScope(jjtn000, true);
12572    jjtc000 = false;
12573    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12574     } catch (Throwable jjte000) {
12575    if (jjtc000) {
12576      jjtree.clearNodeScope(jjtn000);
12577      jjtc000 = false;
12578    } else {
12579      jjtree.popNode();
12580    }
12581    if (jjte000 instanceof RuntimeException) {
12582      {if (true) throw (RuntimeException)jjte000;}
12583    }
12584    if (jjte000 instanceof ParseException) {
12585      {if (true) throw (ParseException)jjte000;}
12586    }
12587    {if (true) throw (Error)jjte000;}
12588     } finally {
12589    if (jjtc000) {
12590      jjtree.closeNodeScope(jjtn000, true);
12591    }
12592     }
12593     throw new Error("Missing return statement in function");
12594   }
12595 
12596 /**
12597 ForAllIndex is declared implicitly, unlike most variables or constants.
12598 */
12599   final public ASTForAllIndex ForAllIndex() throws ParseException {
12600  /*@bgen(jjtree) ForAllIndex */
12601  ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12602  boolean jjtc000 = true;
12603  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12604     try {
12605       simpleNode = ID();
12606    jjtree.closeNodeScope(jjtn000, true);
12607    jjtc000 = false;
12608    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12609     } catch (Throwable jjte000) {
12610    if (jjtc000) {
12611      jjtree.clearNodeScope(jjtn000);
12612      jjtc000 = false;
12613    } else {
12614      jjtree.popNode();
12615    }
12616    if (jjte000 instanceof RuntimeException) {
12617      {if (true) throw (RuntimeException)jjte000;}
12618    }
12619    if (jjte000 instanceof ParseException) {
12620      {if (true) throw (ParseException)jjte000;}
12621    }
12622    {if (true) throw (Error)jjte000;}
12623     } finally {
12624    if (jjtc000) {
12625      jjtree.closeNodeScope(jjtn000, true);
12626    }
12627     }
12628     throw new Error("Missing return statement in function");
12629   }
12630 
12631   final public ASTForAllStatement ForAllStatement() throws ParseException {
12632  /*@bgen(jjtree) ForAllStatement */
12633   ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12634   boolean jjtc000 = true;
12635   jjtree.openNodeScope(jjtn000);
12636     try {
12637       jj_consume_token(FORALL);
12638       ForAllIndex();
12639       jj_consume_token(IN);
12640       switch (jj_nt.kind) {
12641       case INDICES:
12642       case VALUES:
12643         switch (jj_nt.kind) {
12644         case INDICES:
12645           jj_consume_token(INDICES);
12646           break;
12647         case VALUES:
12648           jj_consume_token(VALUES);
12649           break;
12650         default:
12651           jj_la1[142] = jj_gen;
12652           jj_consume_token(-1);
12653           throw new ParseException();
12654         }
12655         jj_consume_token(OF);
12656         Expression();
12657         break;
12658       case 5:
12659       case 16:
12660       case 17:
12661       case REPLACE:
12662       case DEFINER:
12663       case CURRENT_USER:
12664       case LANGUAGE:
12665       case INLINE:
12666       case ADD:
12667       case AGGREGATE:
12668       case ARRAY:
12669       case AT:
12670       case ATTRIBUTE:
12671       case AUTHID:
12672       case BODY:
12673       case BULK:
12674       case BYTE:
12675       case CASCADE:
12676       case CASE:
12677       case CLOSE:
12678       case COALESCE:
12679       case COLLECT:
12680       case COLUMN:
12681       case COMMENT:
12682       case COMMIT:
12683       case CONSTRUCTOR:
12684       case CONTINUE:
12685       case CONVERT:
12686       case CURRENT:
12687       case CURSOR:
12688       case DATA:
12689       case DATE:
12690       case DAY:
12691       case DISABLE:
12692       case EDITIONABLE:
12693       case ELEMENT:
12694       case ENABLE:
12695       case ESCAPE:
12696       case EXCEPT:
12697       case EXCEPTIONS:
12698       case EXIT:
12699       case EXTERNAL:
12700       case EXTENDS:
12701       case EXTRACT:
12702       case FALSE:
12703       case FINAL:
12704       case FORCE:
12705       case FUNCTION:
12706       case GLOBAL:
12707       case HASH:
12708       case HEAP:
12709       case HOUR:
12710       case IMMEDIATE:
12711       case INDEXTYPE:
12712       case INDICATOR:
12713       case INSTANTIABLE:
12714       case INTERVAL:
12715       case INVALIDATE:
12716       case ISOLATION:
12717       case JAVA:
12718       case LEVEL:
12719       case LIMIT:
12720       case LOOP:
12721       case MAP:
12722       case MAX:
12723       case MEMBER:
12724       case MERGE:
12725       case MIN:
12726       case MINUTE:
12727       case MLSLABEL:
12728       case MODIFY:
12729       case MOD:
12730       case MONTH:
12731       case NATURAL:
12732       case NEW:
12733       case NEW_DOT:
12734       case NO:
12735       case NONEDITIONABLE:
12736       case NOT:
12737       case NULL:
12738       case NULLIF:
12739       case OBJECT:
12740       case OID:
12741       case OPAQUE:
12742       case OPEN:
12743       case OPERATOR:
12744       case ORGANIZATION:
12745       case OTHERS:
12746       case OVERRIDING:
12747       case PACKAGE:
12748       case PARTITION:
12749       case PRESERVE:
12750       case PRIVATE:
12751       case PROCEDURE:
12752       case RANGE:
12753       case RAW:
12754       case REAL:
12755       case RECORD:
12756       case REF:
12757       case RELEASE:
12758       case RELIES_ON:
12759       case RENAME:
12760       case RESULT:
12761       case RETURN:
12762       case RETURNING:
12763       case REVERSE:
12764       case ROLLBACK:
12765       case ROW:
12766       case ROWS:
12767       case ROWID:
12768       case ROWNUM:
12769       case SAVE:
12770       case SAVEPOINT:
12771       case SECOND:
12772       case SELECT:
12773       case SELF:
12774       case SET:
12775       case SPACE:
12776       case SQL:
12777       case SQLCODE:
12778       case SQLERRM:
12779       case STATIC:
12780       case SUBTYPE:
12781       case SUBSTITUTABLE:
12782       case SUCCESSFUL:
12783       case SYSDATE:
12784       case SYS_REFCURSOR:
12785       case TEMPORARY:
12786       case TIME:
12787       case TIMESTAMP:
12788       case TIMEZONE_REGION:
12789       case TIMEZONE_ABBR:
12790       case TIMEZONE_MINUTE:
12791       case TIMEZONE_HOUR:
12792       case TRANSACTION:
12793       case TRUE:
12794       case TYPE:
12795       case UNDER:
12796       case USING:
12797       case YES:
12798       case SHOW:
12799       case A:
12800       case DOUBLE:
12801       case DEC:
12802       case PRECISION:
12803       case INT:
12804       case NUMERIC:
12805       case NCHAR:
12806       case NVARCHAR2:
12807       case STRING:
12808       case UROWID:
12809       case VARRAY:
12810       case VARYING:
12811       case BFILE:
12812       case BLOB:
12813       case CLOB:
12814       case NCLOB:
12815       case YEAR:
12816       case LOCAL:
12817       case WITH:
12818       case ZONE:
12819       case CHARACTER:
12820       case AFTER:
12821       case BEFORE:
12822       case OLD:
12823       case PARENT:
12824       case CC_IF:
12825       case ANALYZE:
12826       case ASSOCIATE:
12827       case AUDIT:
12828       case COMPOUND:
12829       case DATABASE:
12830       case CALL:
12831       case DDL:
12832       case DISASSOCIATE:
12833       case EACH:
12834       case FOLLOWS:
12835       case LOGOFF:
12836       case LOGON:
12837       case NESTED:
12838       case NOAUDIT:
12839       case SCHEMA:
12840       case SERVERERROR:
12841       case SHUTDOWN:
12842       case STARTUP:
12843       case STATEMENT:
12844       case STATISTICS:
12845       case SUSPEND:
12846       case TRUNCATE:
12847       case WRAPPED:
12848       case LIBRARY:
12849       case NAME:
12850       case STRUCT:
12851       case CONTEXT:
12852       case PARAMETERS:
12853       case LENGTH:
12854       case TDO:
12855       case MAXLEN:
12856       case CHARSETID:
12857       case CHARSETFORM:
12858       case ACCEPT:
12859       case ACCESSIBLE:
12860       case COPY:
12861       case DEFINE:
12862       case DISCONNECT:
12863       case HOST:
12864       case PRINT:
12865       case QUIT:
12866       case REMARK:
12867       case UNDEFINE:
12868       case VARIABLE:
12869       case WHENEVER:
12870       case ATTACH:
12871       case CAST:
12872       case TREAT:
12873       case TRIM:
12874       case LEFT:
12875       case RIGHT:
12876       case BOTH:
12877       case EMPTY:
12878       case MULTISET:
12879       case SUBMULTISET:
12880       case LEADING:
12881       case TRAILING:
12882       case CHAR_CS:
12883       case NCHAR_CS:
12884       case DBTIMEZONE:
12885       case SESSIONTIMEZONE:
12886       case AUTHENTICATED:
12887       case LINK:
12888       case SHARED:
12889       case DIRECTORY:
12890       case USER:
12891       case IDENTIFIER:
12892       case UNSIGNED_NUMERIC_LITERAL:
12893       case CHARACTER_LITERAL:
12894       case STRING_LITERAL:
12895       case QUOTED_LITERAL:
12896         Expression();
12897         switch (jj_nt.kind) {
12898         case 12:
12899           jj_consume_token(12);
12900           Expression();
12901           break;
12902         default:
12903           jj_la1[143] = jj_gen;
12904           ;
12905         }
12906         break;
12907       default:
12908         jj_la1[144] = jj_gen;
12909         jj_consume_token(-1);
12910         throw new ParseException();
12911       }
12912       switch (jj_nt.kind) {
12913       case SAVE:
12914         jj_consume_token(SAVE);
12915         jj_consume_token(EXCEPTIONS);
12916         break;
12917       default:
12918         jj_la1[145] = jj_gen;
12919         ;
12920       }
12921       SqlStatement(null,";");
12922         jjtree.closeNodeScope(jjtn000, true);
12923         jjtc000 = false;
12924         {if (true) return jjtn000 ;}
12925     } catch (Throwable jjte000) {
12926            if (jjtc000) {
12927              jjtree.clearNodeScope(jjtn000);
12928              jjtc000 = false;
12929            } else {
12930              jjtree.popNode();
12931            }
12932            if (jjte000 instanceof RuntimeException) {
12933              {if (true) throw (RuntimeException)jjte000;}
12934            }
12935            if (jjte000 instanceof ParseException) {
12936              {if (true) throw (ParseException)jjte000;}
12937            }
12938            {if (true) throw (Error)jjte000;}
12939     } finally {
12940            if (jjtc000) {
12941              jjtree.closeNodeScope(jjtn000, true);
12942            }
12943     }
12944     throw new Error("Missing return statement in function");
12945   }
12946 
12947   final public ASTGotoStatement GotoStatement() throws ParseException {
12948  /*@bgen(jjtree) GotoStatement */
12949  ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12950  boolean jjtc000 = true;
12951  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12952     try {
12953       jj_consume_token(GOTO);
12954       label = QualifiedName();
12955         jjtree.closeNodeScope(jjtn000, true);
12956         jjtc000 = false;
12957         jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12958     } catch (Throwable jjte000) {
12959           if (jjtc000) {
12960             jjtree.clearNodeScope(jjtn000);
12961             jjtc000 = false;
12962           } else {
12963             jjtree.popNode();
12964           }
12965           if (jjte000 instanceof RuntimeException) {
12966             {if (true) throw (RuntimeException)jjte000;}
12967           }
12968           if (jjte000 instanceof ParseException) {
12969             {if (true) throw (ParseException)jjte000;}
12970           }
12971           {if (true) throw (Error)jjte000;}
12972     } finally {
12973           if (jjtc000) {
12974             jjtree.closeNodeScope(jjtn000, true);
12975           }
12976     }
12977     throw new Error("Missing return statement in function");
12978   }
12979 
12980   final public ASTReturnStatement ReturnStatement() throws ParseException {
12981  /*@bgen(jjtree) ReturnStatement */
12982   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12983   boolean jjtc000 = true;
12984   jjtree.openNodeScope(jjtn000);
12985     try {
12986       jj_consume_token(RETURN);
12987       switch (jj_nt.kind) {
12988       case 5:
12989       case 16:
12990       case 17:
12991       case REPLACE:
12992       case DEFINER:
12993       case CURRENT_USER:
12994       case LANGUAGE:
12995       case INLINE:
12996       case ADD:
12997       case AGGREGATE:
12998       case ARRAY:
12999       case AT:
13000       case ATTRIBUTE:
13001       case AUTHID:
13002       case BODY:
13003       case BULK:
13004       case BYTE:
13005       case CASCADE:
13006       case CASE:
13007       case CLOSE:
13008       case COALESCE:
13009       case COLLECT:
13010       case COLUMN:
13011       case COMMENT:
13012       case COMMIT:
13013       case CONSTRUCTOR:
13014       case CONTINUE:
13015       case CONVERT:
13016       case CURRENT:
13017       case CURSOR:
13018       case DATA:
13019       case DATE:
13020       case DAY:
13021       case DISABLE:
13022       case EDITIONABLE:
13023       case ELEMENT:
13024       case ENABLE:
13025       case ESCAPE:
13026       case EXCEPT:
13027       case EXCEPTIONS:
13028       case EXIT:
13029       case EXTERNAL:
13030       case EXTENDS:
13031       case EXTRACT:
13032       case FALSE:
13033       case FINAL:
13034       case FORCE:
13035       case FUNCTION:
13036       case GLOBAL:
13037       case HASH:
13038       case HEAP:
13039       case HOUR:
13040       case IMMEDIATE:
13041       case INDICES:
13042       case INDEXTYPE:
13043       case INDICATOR:
13044       case INSTANTIABLE:
13045       case INTERVAL:
13046       case INVALIDATE:
13047       case ISOLATION:
13048       case JAVA:
13049       case LEVEL:
13050       case LIMIT:
13051       case LOOP:
13052       case MAP:
13053       case MAX:
13054       case MEMBER:
13055       case MERGE:
13056       case MIN:
13057       case MINUTE:
13058       case MLSLABEL:
13059       case MODIFY:
13060       case MOD:
13061       case MONTH:
13062       case NATURAL:
13063       case NEW:
13064       case NEW_DOT:
13065       case NO:
13066       case NONEDITIONABLE:
13067       case NOT:
13068       case NULL:
13069       case NULLIF:
13070       case OBJECT:
13071       case OID:
13072       case OPAQUE:
13073       case OPEN:
13074       case OPERATOR:
13075       case ORGANIZATION:
13076       case OTHERS:
13077       case OVERRIDING:
13078       case PACKAGE:
13079       case PARTITION:
13080       case PRESERVE:
13081       case PRIVATE:
13082       case PROCEDURE:
13083       case RANGE:
13084       case RAW:
13085       case REAL:
13086       case RECORD:
13087       case REF:
13088       case RELEASE:
13089       case RELIES_ON:
13090       case RENAME:
13091       case RESULT:
13092       case RETURN:
13093       case RETURNING:
13094       case REVERSE:
13095       case ROLLBACK:
13096       case ROW:
13097       case ROWS:
13098       case ROWID:
13099       case ROWNUM:
13100       case SAVE:
13101       case SAVEPOINT:
13102       case SECOND:
13103       case SELECT:
13104       case SELF:
13105       case SET:
13106       case SPACE:
13107       case SQL:
13108       case SQLCODE:
13109       case SQLERRM:
13110       case STATIC:
13111       case SUBTYPE:
13112       case SUBSTITUTABLE:
13113       case SUCCESSFUL:
13114       case SYSDATE:
13115       case SYS_REFCURSOR:
13116       case TEMPORARY:
13117       case TIME:
13118       case TIMESTAMP:
13119       case TIMEZONE_REGION:
13120       case TIMEZONE_ABBR:
13121       case TIMEZONE_MINUTE:
13122       case TIMEZONE_HOUR:
13123       case TRANSACTION:
13124       case TRUE:
13125       case TYPE:
13126       case UNDER:
13127       case USING:
13128       case YES:
13129       case SHOW:
13130       case A:
13131       case DOUBLE:
13132       case DEC:
13133       case PRECISION:
13134       case INT:
13135       case NUMERIC:
13136       case NCHAR:
13137       case NVARCHAR2:
13138       case STRING:
13139       case UROWID:
13140       case VARRAY:
13141       case VARYING:
13142       case BFILE:
13143       case BLOB:
13144       case CLOB:
13145       case NCLOB:
13146       case YEAR:
13147       case LOCAL:
13148       case WITH:
13149       case ZONE:
13150       case CHARACTER:
13151       case AFTER:
13152       case BEFORE:
13153       case OLD:
13154       case PARENT:
13155       case CC_IF:
13156       case ANALYZE:
13157       case ASSOCIATE:
13158       case AUDIT:
13159       case COMPOUND:
13160       case DATABASE:
13161       case CALL:
13162       case DDL:
13163       case DISASSOCIATE:
13164       case EACH:
13165       case FOLLOWS:
13166       case LOGOFF:
13167       case LOGON:
13168       case NESTED:
13169       case NOAUDIT:
13170       case SCHEMA:
13171       case SERVERERROR:
13172       case SHUTDOWN:
13173       case STARTUP:
13174       case STATEMENT:
13175       case STATISTICS:
13176       case SUSPEND:
13177       case TRUNCATE:
13178       case WRAPPED:
13179       case LIBRARY:
13180       case NAME:
13181       case STRUCT:
13182       case CONTEXT:
13183       case PARAMETERS:
13184       case LENGTH:
13185       case TDO:
13186       case MAXLEN:
13187       case CHARSETID:
13188       case CHARSETFORM:
13189       case ACCEPT:
13190       case ACCESSIBLE:
13191       case COPY:
13192       case DEFINE:
13193       case DISCONNECT:
13194       case HOST:
13195       case PRINT:
13196       case QUIT:
13197       case REMARK:
13198       case UNDEFINE:
13199       case VARIABLE:
13200       case WHENEVER:
13201       case ATTACH:
13202       case CAST:
13203       case TREAT:
13204       case TRIM:
13205       case LEFT:
13206       case RIGHT:
13207       case BOTH:
13208       case EMPTY:
13209       case MULTISET:
13210       case SUBMULTISET:
13211       case LEADING:
13212       case TRAILING:
13213       case CHAR_CS:
13214       case NCHAR_CS:
13215       case DBTIMEZONE:
13216       case SESSIONTIMEZONE:
13217       case AUTHENTICATED:
13218       case LINK:
13219       case SHARED:
13220       case DIRECTORY:
13221       case USER:
13222       case IDENTIFIER:
13223       case UNSIGNED_NUMERIC_LITERAL:
13224       case CHARACTER_LITERAL:
13225       case STRING_LITERAL:
13226       case QUOTED_LITERAL:
13227         Expression();
13228         break;
13229       default:
13230         jj_la1[146] = jj_gen;
13231         ;
13232       }
13233         jjtree.closeNodeScope(jjtn000, true);
13234         jjtc000 = false;
13235         {if (true) return jjtn000 ;}
13236     } catch (Throwable jjte000) {
13237           if (jjtc000) {
13238             jjtree.clearNodeScope(jjtn000);
13239             jjtc000 = false;
13240           } else {
13241             jjtree.popNode();
13242           }
13243           if (jjte000 instanceof RuntimeException) {
13244             {if (true) throw (RuntimeException)jjte000;}
13245           }
13246           if (jjte000 instanceof ParseException) {
13247             {if (true) throw (ParseException)jjte000;}
13248           }
13249           {if (true) throw (Error)jjte000;}
13250     } finally {
13251           if (jjtc000) {
13252             jjtree.closeNodeScope(jjtn000, true);
13253           }
13254     }
13255     throw new Error("Missing return statement in function");
13256   }
13257 
13258   final public ASTContinueStatement ContinueStatement() throws ParseException {
13259  /*@bgen(jjtree) ContinueStatement */
13260  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13261  boolean jjtc000 = true;
13262  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13263     try {
13264       jj_consume_token(CONTINUE);
13265       switch (jj_nt.kind) {
13266       case REPLACE:
13267       case DEFINER:
13268       case CURRENT_USER:
13269       case LANGUAGE:
13270       case INLINE:
13271       case ADD:
13272       case AGGREGATE:
13273       case ARRAY:
13274       case AT:
13275       case ATTRIBUTE:
13276       case AUTHID:
13277       case BODY:
13278       case BULK:
13279       case BYTE:
13280       case CASCADE:
13281       case CLOSE:
13282       case COALESCE:
13283       case COLLECT:
13284       case COLUMN:
13285       case COMMENT:
13286       case COMMIT:
13287       case CONSTRUCTOR:
13288       case CONTINUE:
13289       case CONVERT:
13290       case CURRENT:
13291       case CURSOR:
13292       case DATA:
13293       case DAY:
13294       case DISABLE:
13295       case EDITIONABLE:
13296       case ELEMENT:
13297       case ENABLE:
13298       case ESCAPE:
13299       case EXCEPT:
13300       case EXCEPTIONS:
13301       case EXIT:
13302       case EXTERNAL:
13303       case EXTENDS:
13304       case EXTRACT:
13305       case FALSE:
13306       case FINAL:
13307       case FORCE:
13308       case FUNCTION:
13309       case GLOBAL:
13310       case HASH:
13311       case HEAP:
13312       case HOUR:
13313       case IMMEDIATE:
13314       case INDICES:
13315       case INDEXTYPE:
13316       case INDICATOR:
13317       case INSTANTIABLE:
13318       case INTERVAL:
13319       case INVALIDATE:
13320       case ISOLATION:
13321       case JAVA:
13322       case LEVEL:
13323       case LIMIT:
13324       case LOOP:
13325       case MAP:
13326       case MAX:
13327       case MEMBER:
13328       case MERGE:
13329       case MIN:
13330       case MINUTE:
13331       case MLSLABEL:
13332       case MODIFY:
13333       case MOD:
13334       case MONTH:
13335       case NATURAL:
13336       case NEW:
13337       case NO:
13338       case NONEDITIONABLE:
13339       case NULLIF:
13340       case OBJECT:
13341       case OID:
13342       case OPAQUE:
13343       case OPEN:
13344       case OPERATOR:
13345       case ORGANIZATION:
13346       case OTHERS:
13347       case OVERRIDING:
13348       case PACKAGE:
13349       case PARTITION:
13350       case PRESERVE:
13351       case PRIVATE:
13352       case PROCEDURE:
13353       case RANGE:
13354       case RAW:
13355       case REAL:
13356       case RECORD:
13357       case REF:
13358       case RELEASE:
13359       case RELIES_ON:
13360       case RENAME:
13361       case RESULT:
13362       case RETURN:
13363       case RETURNING:
13364       case REVERSE:
13365       case ROLLBACK:
13366       case ROW:
13367       case ROWS:
13368       case ROWID:
13369       case ROWNUM:
13370       case SAVE:
13371       case SAVEPOINT:
13372       case SECOND:
13373       case SELF:
13374       case SET:
13375       case SPACE:
13376       case SQL:
13377       case SQLCODE:
13378       case SQLERRM:
13379       case STATIC:
13380       case SUBTYPE:
13381       case SUBSTITUTABLE:
13382       case SUCCESSFUL:
13383       case SYSDATE:
13384       case SYS_REFCURSOR:
13385       case TEMPORARY:
13386       case TIME:
13387       case TIMESTAMP:
13388       case TIMEZONE_REGION:
13389       case TIMEZONE_ABBR:
13390       case TIMEZONE_MINUTE:
13391       case TIMEZONE_HOUR:
13392       case TRANSACTION:
13393       case TRUE:
13394       case TYPE:
13395       case UNDER:
13396       case USING:
13397       case YES:
13398       case SHOW:
13399       case A:
13400       case DOUBLE:
13401       case DEC:
13402       case PRECISION:
13403       case INT:
13404       case NUMERIC:
13405       case NCHAR:
13406       case NVARCHAR2:
13407       case STRING:
13408       case UROWID:
13409       case VARRAY:
13410       case VARYING:
13411       case BFILE:
13412       case BLOB:
13413       case CLOB:
13414       case NCLOB:
13415       case YEAR:
13416       case LOCAL:
13417       case ZONE:
13418       case CHARACTER:
13419       case AFTER:
13420       case BEFORE:
13421       case OLD:
13422       case PARENT:
13423       case ANALYZE:
13424       case ASSOCIATE:
13425       case AUDIT:
13426       case COMPOUND:
13427       case DATABASE:
13428       case CALL:
13429       case DDL:
13430       case DISASSOCIATE:
13431       case EACH:
13432       case FOLLOWS:
13433       case LOGOFF:
13434       case LOGON:
13435       case NESTED:
13436       case NOAUDIT:
13437       case SCHEMA:
13438       case SERVERERROR:
13439       case SHUTDOWN:
13440       case STARTUP:
13441       case STATEMENT:
13442       case STATISTICS:
13443       case SUSPEND:
13444       case TRUNCATE:
13445       case WRAPPED:
13446       case LIBRARY:
13447       case NAME:
13448       case STRUCT:
13449       case CONTEXT:
13450       case PARAMETERS:
13451       case LENGTH:
13452       case TDO:
13453       case MAXLEN:
13454       case CHARSETID:
13455       case CHARSETFORM:
13456       case ACCEPT:
13457       case ACCESSIBLE:
13458       case COPY:
13459       case DEFINE:
13460       case DISCONNECT:
13461       case HOST:
13462       case PRINT:
13463       case QUIT:
13464       case REMARK:
13465       case UNDEFINE:
13466       case VARIABLE:
13467       case WHENEVER:
13468       case ATTACH:
13469       case CAST:
13470       case TREAT:
13471       case TRIM:
13472       case LEFT:
13473       case RIGHT:
13474       case BOTH:
13475       case EMPTY:
13476       case MULTISET:
13477       case SUBMULTISET:
13478       case LEADING:
13479       case TRAILING:
13480       case CHAR_CS:
13481       case NCHAR_CS:
13482       case DBTIMEZONE:
13483       case SESSIONTIMEZONE:
13484       case AUTHENTICATED:
13485       case LINK:
13486       case SHARED:
13487       case DIRECTORY:
13488       case USER:
13489       case IDENTIFIER:
13490       case QUOTED_LITERAL:
13491         label = UnqualifiedID();
13492         break;
13493       default:
13494         jj_la1[147] = jj_gen;
13495         ;
13496       }
13497       switch (jj_nt.kind) {
13498       case WHEN:
13499         jj_consume_token(WHEN);
13500         Expression();
13501         break;
13502       default:
13503         jj_la1[148] = jj_gen;
13504         ;
13505       }
13506         jjtree.closeNodeScope(jjtn000, true);
13507         jjtc000 = false;
13508         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13509     } catch (Throwable jjte000) {
13510           if (jjtc000) {
13511             jjtree.clearNodeScope(jjtn000);
13512             jjtc000 = false;
13513           } else {
13514             jjtree.popNode();
13515           }
13516           if (jjte000 instanceof RuntimeException) {
13517             {if (true) throw (RuntimeException)jjte000;}
13518           }
13519           if (jjte000 instanceof ParseException) {
13520             {if (true) throw (ParseException)jjte000;}
13521           }
13522           {if (true) throw (Error)jjte000;}
13523     } finally {
13524           if (jjtc000) {
13525             jjtree.closeNodeScope(jjtn000, true);
13526           }
13527     }
13528     throw new Error("Missing return statement in function");
13529   }
13530 
13531   final public ASTExitStatement ExitStatement() throws ParseException {
13532  /*@bgen(jjtree) ExitStatement */
13533  ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13534  boolean jjtc000 = true;
13535  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13536     try {
13537       jj_consume_token(EXIT);
13538       switch (jj_nt.kind) {
13539       case REPLACE:
13540       case DEFINER:
13541       case CURRENT_USER:
13542       case LANGUAGE:
13543       case INLINE:
13544       case ADD:
13545       case AGGREGATE:
13546       case ARRAY:
13547       case AT:
13548       case ATTRIBUTE:
13549       case AUTHID:
13550       case BODY:
13551       case BULK:
13552       case BYTE:
13553       case CASCADE:
13554       case CLOSE:
13555       case COALESCE:
13556       case COLLECT:
13557       case COLUMN:
13558       case COMMENT:
13559       case COMMIT:
13560       case CONSTRUCTOR:
13561       case CONTINUE:
13562       case CONVERT:
13563       case CURRENT:
13564       case CURSOR:
13565       case DATA:
13566       case DAY:
13567       case DISABLE:
13568       case EDITIONABLE:
13569       case ELEMENT:
13570       case ENABLE:
13571       case ESCAPE:
13572       case EXCEPT:
13573       case EXCEPTIONS:
13574       case EXIT:
13575       case EXTERNAL:
13576       case EXTENDS:
13577       case EXTRACT:
13578       case FALSE:
13579       case FINAL:
13580       case FORCE:
13581       case FUNCTION:
13582       case GLOBAL:
13583       case HASH:
13584       case HEAP:
13585       case HOUR:
13586       case IMMEDIATE:
13587       case INDICES:
13588       case INDEXTYPE:
13589       case INDICATOR:
13590       case INSTANTIABLE:
13591       case INTERVAL:
13592       case INVALIDATE:
13593       case ISOLATION:
13594       case JAVA:
13595       case LEVEL:
13596       case LIMIT:
13597       case LOOP:
13598       case MAP:
13599       case MAX:
13600       case MEMBER:
13601       case MERGE:
13602       case MIN:
13603       case MINUTE:
13604       case MLSLABEL:
13605       case MODIFY:
13606       case MOD:
13607       case MONTH:
13608       case NATURAL:
13609       case NEW:
13610       case NO:
13611       case NONEDITIONABLE:
13612       case NULLIF:
13613       case OBJECT:
13614       case OID:
13615       case OPAQUE:
13616       case OPEN:
13617       case OPERATOR:
13618       case ORGANIZATION:
13619       case OTHERS:
13620       case OVERRIDING:
13621       case PACKAGE:
13622       case PARTITION:
13623       case PRESERVE:
13624       case PRIVATE:
13625       case PROCEDURE:
13626       case RANGE:
13627       case RAW:
13628       case REAL:
13629       case RECORD:
13630       case REF:
13631       case RELEASE:
13632       case RELIES_ON:
13633       case RENAME:
13634       case RESULT:
13635       case RETURN:
13636       case RETURNING:
13637       case REVERSE:
13638       case ROLLBACK:
13639       case ROW:
13640       case ROWS:
13641       case ROWID:
13642       case ROWNUM:
13643       case SAVE:
13644       case SAVEPOINT:
13645       case SECOND:
13646       case SELF:
13647       case SET:
13648       case SPACE:
13649       case SQL:
13650       case SQLCODE:
13651       case SQLERRM:
13652       case STATIC:
13653       case SUBTYPE:
13654       case SUBSTITUTABLE:
13655       case SUCCESSFUL:
13656       case SYSDATE:
13657       case SYS_REFCURSOR:
13658       case TEMPORARY:
13659       case TIME:
13660       case TIMESTAMP:
13661       case TIMEZONE_REGION:
13662       case TIMEZONE_ABBR:
13663       case TIMEZONE_MINUTE:
13664       case TIMEZONE_HOUR:
13665       case TRANSACTION:
13666       case TRUE:
13667       case TYPE:
13668       case UNDER:
13669       case USING:
13670       case YES:
13671       case SHOW:
13672       case A:
13673       case DOUBLE:
13674       case DEC:
13675       case PRECISION:
13676       case INT:
13677       case NUMERIC:
13678       case NCHAR:
13679       case NVARCHAR2:
13680       case STRING:
13681       case UROWID:
13682       case VARRAY:
13683       case VARYING:
13684       case BFILE:
13685       case BLOB:
13686       case CLOB:
13687       case NCLOB:
13688       case YEAR:
13689       case LOCAL:
13690       case ZONE:
13691       case CHARACTER:
13692       case AFTER:
13693       case BEFORE:
13694       case OLD:
13695       case PARENT:
13696       case ANALYZE:
13697       case ASSOCIATE:
13698       case AUDIT:
13699       case COMPOUND:
13700       case DATABASE:
13701       case CALL:
13702       case DDL:
13703       case DISASSOCIATE:
13704       case EACH:
13705       case FOLLOWS:
13706       case LOGOFF:
13707       case LOGON:
13708       case NESTED:
13709       case NOAUDIT:
13710       case SCHEMA:
13711       case SERVERERROR:
13712       case SHUTDOWN:
13713       case STARTUP:
13714       case STATEMENT:
13715       case STATISTICS:
13716       case SUSPEND:
13717       case TRUNCATE:
13718       case WRAPPED:
13719       case LIBRARY:
13720       case NAME:
13721       case STRUCT:
13722       case CONTEXT:
13723       case PARAMETERS:
13724       case LENGTH:
13725       case TDO:
13726       case MAXLEN:
13727       case CHARSETID:
13728       case CHARSETFORM:
13729       case ACCEPT:
13730       case ACCESSIBLE:
13731       case COPY:
13732       case DEFINE:
13733       case DISCONNECT:
13734       case HOST:
13735       case PRINT:
13736       case QUIT:
13737       case REMARK:
13738       case UNDEFINE:
13739       case VARIABLE:
13740       case WHENEVER:
13741       case ATTACH:
13742       case CAST:
13743       case TREAT:
13744       case TRIM:
13745       case LEFT:
13746       case RIGHT:
13747       case BOTH:
13748       case EMPTY:
13749       case MULTISET:
13750       case SUBMULTISET:
13751       case LEADING:
13752       case TRAILING:
13753       case CHAR_CS:
13754       case NCHAR_CS:
13755       case DBTIMEZONE:
13756       case SESSIONTIMEZONE:
13757       case AUTHENTICATED:
13758       case LINK:
13759       case SHARED:
13760       case DIRECTORY:
13761       case USER:
13762       case IDENTIFIER:
13763       case QUOTED_LITERAL:
13764         label = UnqualifiedID();
13765         break;
13766       default:
13767         jj_la1[149] = jj_gen;
13768         ;
13769       }
13770       switch (jj_nt.kind) {
13771       case WHEN:
13772         jj_consume_token(WHEN);
13773         Expression();
13774         break;
13775       default:
13776         jj_la1[150] = jj_gen;
13777         ;
13778       }
13779         jjtree.closeNodeScope(jjtn000, true);
13780         jjtc000 = false;
13781         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13782     } catch (Throwable jjte000) {
13783           if (jjtc000) {
13784             jjtree.clearNodeScope(jjtn000);
13785             jjtc000 = false;
13786           } else {
13787             jjtree.popNode();
13788           }
13789           if (jjte000 instanceof RuntimeException) {
13790             {if (true) throw (RuntimeException)jjte000;}
13791           }
13792           if (jjte000 instanceof ParseException) {
13793             {if (true) throw (ParseException)jjte000;}
13794           }
13795           {if (true) throw (Error)jjte000;}
13796     } finally {
13797           if (jjtc000) {
13798             jjtree.closeNodeScope(jjtn000, true);
13799           }
13800     }
13801     throw new Error("Missing return statement in function");
13802   }
13803 
13804   final public ASTRaiseStatement RaiseStatement() throws ParseException {
13805  /*@bgen(jjtree) RaiseStatement */
13806  ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13807  boolean jjtc000 = true;
13808  jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13809     try {
13810       jj_consume_token(RAISE);
13811       switch (jj_nt.kind) {
13812       case REPLACE:
13813       case DEFINER:
13814       case CURRENT_USER:
13815       case LANGUAGE:
13816       case INLINE:
13817       case ADD:
13818       case AGGREGATE:
13819       case ARRAY:
13820       case AT:
13821       case ATTRIBUTE:
13822       case AUTHID:
13823       case BODY:
13824       case BULK:
13825       case BYTE:
13826       case CASCADE:
13827       case CLOSE:
13828       case COALESCE:
13829       case COLLECT:
13830       case COLUMN:
13831       case COMMENT:
13832       case COMMIT:
13833       case CONSTRUCTOR:
13834       case CONTINUE:
13835       case CONVERT:
13836       case CURRENT:
13837       case CURSOR:
13838       case DATA:
13839       case DAY:
13840       case DISABLE:
13841       case EDITIONABLE:
13842       case ELEMENT:
13843       case ENABLE:
13844       case ESCAPE:
13845       case EXCEPT:
13846       case EXCEPTIONS:
13847       case EXIT:
13848       case EXTERNAL:
13849       case EXTENDS:
13850       case EXTRACT:
13851       case FALSE:
13852       case FINAL:
13853       case FORCE:
13854       case FUNCTION:
13855       case GLOBAL:
13856       case HASH:
13857       case HEAP:
13858       case HOUR:
13859       case IMMEDIATE:
13860       case INDICES:
13861       case INDEXTYPE:
13862       case INDICATOR:
13863       case INSTANTIABLE:
13864       case INTERVAL:
13865       case INVALIDATE:
13866       case ISOLATION:
13867       case JAVA:
13868       case LEVEL:
13869       case LIMIT:
13870       case LOOP:
13871       case MAP:
13872       case MAX:
13873       case MEMBER:
13874       case MERGE:
13875       case MIN:
13876       case MINUTE:
13877       case MLSLABEL:
13878       case MODIFY:
13879       case MOD:
13880       case MONTH:
13881       case NATURAL:
13882       case NEW:
13883       case NO:
13884       case NONEDITIONABLE:
13885       case NULLIF:
13886       case OBJECT:
13887       case OID:
13888       case OPAQUE:
13889       case OPEN:
13890       case OPERATOR:
13891       case ORGANIZATION:
13892       case OTHERS:
13893       case OVERRIDING:
13894       case PACKAGE:
13895       case PARTITION:
13896       case PRESERVE:
13897       case PRIVATE:
13898       case PROCEDURE:
13899       case RANGE:
13900       case RAW:
13901       case REAL:
13902       case RECORD:
13903       case REF:
13904       case RELEASE:
13905       case RELIES_ON:
13906       case RENAME:
13907       case RESULT:
13908       case RETURN:
13909       case RETURNING:
13910       case REVERSE:
13911       case ROLLBACK:
13912       case ROW:
13913       case ROWS:
13914       case ROWID:
13915       case ROWNUM:
13916       case SAVE:
13917       case SAVEPOINT:
13918       case SECOND:
13919       case SELF:
13920       case SET:
13921       case SPACE:
13922       case SQL:
13923       case SQLCODE:
13924       case SQLERRM:
13925       case STATIC:
13926       case SUBTYPE:
13927       case SUBSTITUTABLE:
13928       case SUCCESSFUL:
13929       case SYSDATE:
13930       case SYS_REFCURSOR:
13931       case TEMPORARY:
13932       case TIME:
13933       case TIMESTAMP:
13934       case TIMEZONE_REGION:
13935       case TIMEZONE_ABBR:
13936       case TIMEZONE_MINUTE:
13937       case TIMEZONE_HOUR:
13938       case TRANSACTION:
13939       case TRUE:
13940       case TYPE:
13941       case UNDER:
13942       case USING:
13943       case YES:
13944       case SHOW:
13945       case A:
13946       case DOUBLE:
13947       case DEC:
13948       case PRECISION:
13949       case INT:
13950       case NUMERIC:
13951       case NCHAR:
13952       case NVARCHAR2:
13953       case STRING:
13954       case UROWID:
13955       case VARRAY:
13956       case VARYING:
13957       case BFILE:
13958       case BLOB:
13959       case CLOB:
13960       case NCLOB:
13961       case YEAR:
13962       case LOCAL:
13963       case ZONE:
13964       case CHARACTER:
13965       case AFTER:
13966       case BEFORE:
13967       case OLD:
13968       case PARENT:
13969       case ANALYZE:
13970       case ASSOCIATE:
13971       case AUDIT:
13972       case COMPOUND:
13973       case DATABASE:
13974       case CALL:
13975       case DDL:
13976       case DISASSOCIATE:
13977       case EACH:
13978       case FOLLOWS:
13979       case LOGOFF:
13980       case LOGON:
13981       case NESTED:
13982       case NOAUDIT:
13983       case SCHEMA:
13984       case SERVERERROR:
13985       case SHUTDOWN:
13986       case STARTUP:
13987       case STATEMENT:
13988       case STATISTICS:
13989       case SUSPEND:
13990       case TRUNCATE:
13991       case WRAPPED:
13992       case LIBRARY:
13993       case NAME:
13994       case STRUCT:
13995       case CONTEXT:
13996       case PARAMETERS:
13997       case LENGTH:
13998       case TDO:
13999       case MAXLEN:
14000       case CHARSETID:
14001       case CHARSETFORM:
14002       case ACCEPT:
14003       case ACCESSIBLE:
14004       case COPY:
14005       case DEFINE:
14006       case DISCONNECT:
14007       case HOST:
14008       case PRINT:
14009       case QUIT:
14010       case REMARK:
14011       case UNDEFINE:
14012       case VARIABLE:
14013       case WHENEVER:
14014       case ATTACH:
14015       case CAST:
14016       case TREAT:
14017       case TRIM:
14018       case LEFT:
14019       case RIGHT:
14020       case BOTH:
14021       case EMPTY:
14022       case MULTISET:
14023       case SUBMULTISET:
14024       case LEADING:
14025       case TRAILING:
14026       case CHAR_CS:
14027       case NCHAR_CS:
14028       case DBTIMEZONE:
14029       case SESSIONTIMEZONE:
14030       case AUTHENTICATED:
14031       case LINK:
14032       case SHARED:
14033       case DIRECTORY:
14034       case USER:
14035       case IDENTIFIER:
14036       case QUOTED_LITERAL:
14037         exception = QualifiedName();
14038         break;
14039       default:
14040         jj_la1[151] = jj_gen;
14041         ;
14042       }
14043         jjtree.closeNodeScope(jjtn000, true);
14044         jjtc000 = false;
14045         if (null != exception) { jjtn000.setImage(exception.getImage()) ; }  {if (true) return jjtn000 ;}
14046     } catch (Throwable jjte000) {
14047          if (jjtc000) {
14048            jjtree.clearNodeScope(jjtn000);
14049            jjtc000 = false;
14050          } else {
14051            jjtree.popNode();
14052          }
14053          if (jjte000 instanceof RuntimeException) {
14054            {if (true) throw (RuntimeException)jjte000;}
14055          }
14056          if (jjte000 instanceof ParseException) {
14057            {if (true) throw (ParseException)jjte000;}
14058          }
14059          {if (true) throw (Error)jjte000;}
14060     } finally {
14061          if (jjtc000) {
14062            jjtree.closeNodeScope(jjtn000, true);
14063          }
14064     }
14065     throw new Error("Missing return statement in function");
14066   }
14067 
14068   final public ASTCloseStatement CloseStatement() throws ParseException {
14069  /*@bgen(jjtree) CloseStatement */
14070  ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14071  boolean jjtc000 = true;
14072  jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14073     try {
14074       jj_consume_token(CLOSE);
14075       cursor = QualifiedName();
14076         jjtree.closeNodeScope(jjtn000, true);
14077         jjtc000 = false;
14078         jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14079     } catch (Throwable jjte000) {
14080         if (jjtc000) {
14081           jjtree.clearNodeScope(jjtn000);
14082           jjtc000 = false;
14083         } else {
14084           jjtree.popNode();
14085         }
14086         if (jjte000 instanceof RuntimeException) {
14087           {if (true) throw (RuntimeException)jjte000;}
14088         }
14089         if (jjte000 instanceof ParseException) {
14090           {if (true) throw (ParseException)jjte000;}
14091         }
14092         {if (true) throw (Error)jjte000;}
14093     } finally {
14094         if (jjtc000) {
14095           jjtree.closeNodeScope(jjtn000, true);
14096         }
14097     }
14098     throw new Error("Missing return statement in function");
14099   }
14100 
14101   final public ASTOpenStatement OpenStatement() throws ParseException {
14102  /*@bgen(jjtree) OpenStatement */
14103   ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14104   boolean jjtc000 = true;
14105   jjtree.openNodeScope(jjtn000);
14106     try {
14107       jj_consume_token(OPEN);
14108       switch (jj_nt.kind) {
14109       case 5:
14110       case 16:
14111       case 17:
14112       case REPLACE:
14113       case DEFINER:
14114       case CURRENT_USER:
14115       case LANGUAGE:
14116       case INLINE:
14117       case ADD:
14118       case AGGREGATE:
14119       case ARRAY:
14120       case AT:
14121       case ATTRIBUTE:
14122       case AUTHID:
14123       case BODY:
14124       case BULK:
14125       case BYTE:
14126       case CASCADE:
14127       case CASE:
14128       case CLOSE:
14129       case COALESCE:
14130       case COLLECT:
14131       case COLUMN:
14132       case COMMENT:
14133       case COMMIT:
14134       case CONSTRUCTOR:
14135       case CONTINUE:
14136       case CONVERT:
14137       case CURRENT:
14138       case CURSOR:
14139       case DATA:
14140       case DATE:
14141       case DAY:
14142       case DISABLE:
14143       case EDITIONABLE:
14144       case ELEMENT:
14145       case ENABLE:
14146       case ESCAPE:
14147       case EXCEPT:
14148       case EXCEPTIONS:
14149       case EXIT:
14150       case EXTERNAL:
14151       case EXTENDS:
14152       case EXTRACT:
14153       case FALSE:
14154       case FINAL:
14155       case FORCE:
14156       case FUNCTION:
14157       case GLOBAL:
14158       case HASH:
14159       case HEAP:
14160       case HOUR:
14161       case IMMEDIATE:
14162       case INDICES:
14163       case INDEXTYPE:
14164       case INDICATOR:
14165       case INSTANTIABLE:
14166       case INTERVAL:
14167       case INVALIDATE:
14168       case ISOLATION:
14169       case JAVA:
14170       case LEVEL:
14171       case LIMIT:
14172       case LOOP:
14173       case MAP:
14174       case MAX:
14175       case MEMBER:
14176       case MERGE:
14177       case MIN:
14178       case MINUTE:
14179       case MLSLABEL:
14180       case MODIFY:
14181       case MOD:
14182       case MONTH:
14183       case NATURAL:
14184       case NEW:
14185       case NEW_DOT:
14186       case NO:
14187       case NONEDITIONABLE:
14188       case NOT:
14189       case NULL:
14190       case NULLIF:
14191       case OBJECT:
14192       case OID:
14193       case OPAQUE:
14194       case OPEN:
14195       case OPERATOR:
14196       case ORGANIZATION:
14197       case OTHERS:
14198       case OVERRIDING:
14199       case PACKAGE:
14200       case PARTITION:
14201       case PRESERVE:
14202       case PRIVATE:
14203       case PROCEDURE:
14204       case RANGE:
14205       case RAW:
14206       case REAL:
14207       case RECORD:
14208       case REF:
14209       case RELEASE:
14210       case RELIES_ON:
14211       case RENAME:
14212       case RESULT:
14213       case RETURN:
14214       case RETURNING:
14215       case REVERSE:
14216       case ROLLBACK:
14217       case ROW:
14218       case ROWS:
14219       case ROWID:
14220       case ROWNUM:
14221       case SAVE:
14222       case SAVEPOINT:
14223       case SECOND:
14224       case SELECT:
14225       case SELF:
14226       case SET:
14227       case SPACE:
14228       case SQL:
14229       case SQLCODE:
14230       case SQLERRM:
14231       case STATIC:
14232       case SUBTYPE:
14233       case SUBSTITUTABLE:
14234       case SUCCESSFUL:
14235       case SYSDATE:
14236       case SYS_REFCURSOR:
14237       case TEMPORARY:
14238       case TIME:
14239       case TIMESTAMP:
14240       case TIMEZONE_REGION:
14241       case TIMEZONE_ABBR:
14242       case TIMEZONE_MINUTE:
14243       case TIMEZONE_HOUR:
14244       case TRANSACTION:
14245       case TRUE:
14246       case TYPE:
14247       case UNDER:
14248       case USING:
14249       case YES:
14250       case SHOW:
14251       case A:
14252       case DOUBLE:
14253       case DEC:
14254       case PRECISION:
14255       case INT:
14256       case NUMERIC:
14257       case NCHAR:
14258       case NVARCHAR2:
14259       case STRING:
14260       case UROWID:
14261       case VARRAY:
14262       case VARYING:
14263       case BFILE:
14264       case BLOB:
14265       case CLOB:
14266       case NCLOB:
14267       case YEAR:
14268       case LOCAL:
14269       case WITH:
14270       case ZONE:
14271       case CHARACTER:
14272       case AFTER:
14273       case BEFORE:
14274       case OLD:
14275       case PARENT:
14276       case CC_IF:
14277       case ANALYZE:
14278       case ASSOCIATE:
14279       case AUDIT:
14280       case COMPOUND:
14281       case DATABASE:
14282       case CALL:
14283       case DDL:
14284       case DISASSOCIATE:
14285       case EACH:
14286       case FOLLOWS:
14287       case LOGOFF:
14288       case LOGON:
14289       case NESTED:
14290       case NOAUDIT:
14291       case SCHEMA:
14292       case SERVERERROR:
14293       case SHUTDOWN:
14294       case STARTUP:
14295       case STATEMENT:
14296       case STATISTICS:
14297       case SUSPEND:
14298       case TRUNCATE:
14299       case WRAPPED:
14300       case LIBRARY:
14301       case NAME:
14302       case STRUCT:
14303       case CONTEXT:
14304       case PARAMETERS:
14305       case LENGTH:
14306       case TDO:
14307       case MAXLEN:
14308       case CHARSETID:
14309       case CHARSETFORM:
14310       case ACCEPT:
14311       case ACCESSIBLE:
14312       case COPY:
14313       case DEFINE:
14314       case DISCONNECT:
14315       case HOST:
14316       case PRINT:
14317       case QUIT:
14318       case REMARK:
14319       case UNDEFINE:
14320       case VARIABLE:
14321       case WHENEVER:
14322       case ATTACH:
14323       case CAST:
14324       case TREAT:
14325       case TRIM:
14326       case LEFT:
14327       case RIGHT:
14328       case BOTH:
14329       case EMPTY:
14330       case MULTISET:
14331       case SUBMULTISET:
14332       case LEADING:
14333       case TRAILING:
14334       case CHAR_CS:
14335       case NCHAR_CS:
14336       case DBTIMEZONE:
14337       case SESSIONTIMEZONE:
14338       case AUTHENTICATED:
14339       case LINK:
14340       case SHARED:
14341       case DIRECTORY:
14342       case USER:
14343       case IDENTIFIER:
14344       case UNSIGNED_NUMERIC_LITERAL:
14345       case CHARACTER_LITERAL:
14346       case STRING_LITERAL:
14347       case QUOTED_LITERAL:
14348         Expression();
14349         break;
14350       default:
14351         jj_la1[152] = jj_gen;
14352         ;
14353       }
14354       switch (jj_nt.kind) {
14355       case FOR:
14356         jj_consume_token(FOR);
14357         Expression();
14358         switch (jj_nt.kind) {
14359         case USING:
14360           jj_consume_token(USING);
14361           switch (jj_nt.kind) {
14362           case IN:
14363           case IN_OUT:
14364           case OUT:
14365             switch (jj_nt.kind) {
14366             case IN:
14367               jj_consume_token(IN);
14368               break;
14369             case OUT:
14370               jj_consume_token(OUT);
14371               break;
14372             case IN_OUT:
14373               jj_consume_token(IN_OUT);
14374               break;
14375             default:
14376               jj_la1[153] = jj_gen;
14377               jj_consume_token(-1);
14378               throw new ParseException();
14379             }
14380             break;
14381           default:
14382             jj_la1[154] = jj_gen;
14383             ;
14384           }
14385           Expression();
14386           label_34:
14387           while (true) {
14388             switch (jj_nt.kind) {
14389             case 6:
14390               ;
14391               break;
14392             default:
14393               jj_la1[155] = jj_gen;
14394               break label_34;
14395             }
14396             jj_consume_token(6);
14397             switch (jj_nt.kind) {
14398             case IN:
14399             case IN_OUT:
14400             case OUT:
14401               switch (jj_nt.kind) {
14402               case IN:
14403                 jj_consume_token(IN);
14404                 break;
14405               case OUT:
14406                 jj_consume_token(OUT);
14407                 break;
14408               case IN_OUT:
14409                 jj_consume_token(IN_OUT);
14410                 break;
14411               default:
14412                 jj_la1[156] = jj_gen;
14413                 jj_consume_token(-1);
14414                 throw new ParseException();
14415               }
14416               break;
14417             default:
14418               jj_la1[157] = jj_gen;
14419               ;
14420             }
14421             Expression();
14422           }
14423           break;
14424         default:
14425           jj_la1[158] = jj_gen;
14426           ;
14427         }
14428         break;
14429       default:
14430         jj_la1[159] = jj_gen;
14431         ;
14432       }
14433         jjtree.closeNodeScope(jjtn000, true);
14434         jjtc000 = false;
14435         {if (true) return jjtn000 ;}
14436     } catch (Throwable jjte000) {
14437            if (jjtc000) {
14438              jjtree.clearNodeScope(jjtn000);
14439              jjtc000 = false;
14440            } else {
14441              jjtree.popNode();
14442            }
14443            if (jjte000 instanceof RuntimeException) {
14444              {if (true) throw (RuntimeException)jjte000;}
14445            }
14446            if (jjte000 instanceof ParseException) {
14447              {if (true) throw (ParseException)jjte000;}
14448            }
14449            {if (true) throw (Error)jjte000;}
14450     } finally {
14451            if (jjtc000) {
14452              jjtree.closeNodeScope(jjtn000, true);
14453            }
14454     }
14455     throw new Error("Missing return statement in function");
14456   }
14457 
14458   final public ASTFetchStatement FetchStatement() throws ParseException {
14459  /*@bgen(jjtree) FetchStatement */
14460   ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14461   boolean jjtc000 = true;
14462   jjtree.openNodeScope(jjtn000);
14463     try {
14464       jj_consume_token(FETCH);
14465       QualifiedName();
14466       switch (jj_nt.kind) {
14467       case BULK:
14468         jj_consume_token(BULK);
14469         jj_consume_token(COLLECT);
14470         break;
14471       default:
14472         jj_la1[160] = jj_gen;
14473         ;
14474       }
14475       jj_consume_token(INTO);
14476       Expression();
14477       label_35:
14478       while (true) {
14479         switch (jj_nt.kind) {
14480         case 6:
14481           ;
14482           break;
14483         default:
14484           jj_la1[161] = jj_gen;
14485           break label_35;
14486         }
14487         jj_consume_token(6);
14488         Expression();
14489       }
14490       switch (jj_nt.kind) {
14491       case LIMIT:
14492         jj_consume_token(LIMIT);
14493         Expression();
14494         break;
14495       default:
14496         jj_la1[162] = jj_gen;
14497         ;
14498       }
14499         jjtree.closeNodeScope(jjtn000, true);
14500         jjtc000 = false;
14501         {if (true) return jjtn000 ;}
14502     } catch (Throwable jjte000) {
14503            if (jjtc000) {
14504              jjtree.clearNodeScope(jjtn000);
14505              jjtc000 = false;
14506            } else {
14507              jjtree.popNode();
14508            }
14509            if (jjte000 instanceof RuntimeException) {
14510              {if (true) throw (RuntimeException)jjte000;}
14511            }
14512            if (jjte000 instanceof ParseException) {
14513              {if (true) throw (ParseException)jjte000;}
14514            }
14515            {if (true) throw (Error)jjte000;}
14516     } finally {
14517            if (jjtc000) {
14518              jjtree.closeNodeScope(jjtn000, true);
14519            }
14520     }
14521     throw new Error("Missing return statement in function");
14522   }
14523 
14524   final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14525  /*@bgen(jjtree) EmbeddedSqlStatement */
14526   ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14527   boolean jjtc000 = true;
14528   jjtree.openNodeScope(jjtn000);
14529     try {
14530       jj_consume_token(EXECUTE);
14531       jj_consume_token(IMMEDIATE);
14532       Expression();
14533       switch (jj_nt.kind) {
14534       case INTO:
14535         jj_consume_token(INTO);
14536         Name();
14537         label_36:
14538         while (true) {
14539           switch (jj_nt.kind) {
14540           case 6:
14541             ;
14542             break;
14543           default:
14544             jj_la1[163] = jj_gen;
14545             break label_36;
14546           }
14547           jj_consume_token(6);
14548           Name();
14549         }
14550         break;
14551       default:
14552         jj_la1[164] = jj_gen;
14553         ;
14554       }
14555       switch (jj_nt.kind) {
14556       case USING:
14557         jj_consume_token(USING);
14558         switch (jj_nt.kind) {
14559         case IN:
14560         case OUT:
14561           switch (jj_nt.kind) {
14562           case IN:
14563             jj_consume_token(IN);
14564             switch (jj_nt.kind) {
14565             case OUT:
14566               jj_consume_token(OUT);
14567               break;
14568             default:
14569               jj_la1[165] = jj_gen;
14570               ;
14571             }
14572             break;
14573           case OUT:
14574             jj_consume_token(OUT);
14575             break;
14576           default:
14577             jj_la1[166] = jj_gen;
14578             jj_consume_token(-1);
14579             throw new ParseException();
14580           }
14581           break;
14582         default:
14583           jj_la1[167] = jj_gen;
14584           ;
14585         }
14586         Expression();
14587         label_37:
14588         while (true) {
14589           switch (jj_nt.kind) {
14590           case 6:
14591             ;
14592             break;
14593           default:
14594             jj_la1[168] = jj_gen;
14595             break label_37;
14596           }
14597           jj_consume_token(6);
14598           switch (jj_nt.kind) {
14599           case IN:
14600           case OUT:
14601             switch (jj_nt.kind) {
14602             case IN:
14603               jj_consume_token(IN);
14604               switch (jj_nt.kind) {
14605               case OUT:
14606                 jj_consume_token(OUT);
14607                 break;
14608               default:
14609                 jj_la1[169] = jj_gen;
14610                 ;
14611               }
14612               break;
14613             case OUT:
14614               jj_consume_token(OUT);
14615               break;
14616             default:
14617               jj_la1[170] = jj_gen;
14618               jj_consume_token(-1);
14619               throw new ParseException();
14620             }
14621             break;
14622           default:
14623             jj_la1[171] = jj_gen;
14624             ;
14625           }
14626           Expression();
14627         }
14628         break;
14629       default:
14630         jj_la1[172] = jj_gen;
14631         ;
14632       }
14633       switch (jj_nt.kind) {
14634       case RETURN:
14635       case RETURNING:
14636         switch (jj_nt.kind) {
14637         case RETURN:
14638           jj_consume_token(RETURN);
14639           break;
14640         case RETURNING:
14641           jj_consume_token(RETURNING);
14642           break;
14643         default:
14644           jj_la1[173] = jj_gen;
14645           jj_consume_token(-1);
14646           throw new ParseException();
14647         }
14648         jj_consume_token(INTO);
14649         Expression();
14650         label_38:
14651         while (true) {
14652           switch (jj_nt.kind) {
14653           case 6:
14654             ;
14655             break;
14656           default:
14657             jj_la1[174] = jj_gen;
14658             break label_38;
14659           }
14660           jj_consume_token(6);
14661           Expression();
14662         }
14663         break;
14664       default:
14665         jj_la1[175] = jj_gen;
14666         ;
14667       }
14668       jj_consume_token(4);
14669         jjtree.closeNodeScope(jjtn000, true);
14670         jjtc000 = false;
14671         {if (true) return jjtn000 ;}
14672     } catch (Throwable jjte000) {
14673      if (jjtc000) {
14674        jjtree.clearNodeScope(jjtn000);
14675        jjtc000 = false;
14676      } else {
14677        jjtree.popNode();
14678      }
14679      if (jjte000 instanceof RuntimeException) {
14680        {if (true) throw (RuntimeException)jjte000;}
14681      }
14682      if (jjte000 instanceof ParseException) {
14683        {if (true) throw (ParseException)jjte000;}
14684      }
14685      {if (true) throw (Error)jjte000;}
14686     } finally {
14687      if (jjtc000) {
14688        jjtree.closeNodeScope(jjtn000, true);
14689      }
14690     }
14691     throw new Error("Missing return statement in function");
14692   }
14693 
14694   final public ASTPipelineStatement PipelineStatement() throws ParseException {
14695  /*@bgen(jjtree) PipelineStatement */
14696   ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14697   boolean jjtc000 = true;
14698   jjtree.openNodeScope(jjtn000);
14699     try {
14700       jj_consume_token(PIPE);
14701       jj_consume_token(ROW);
14702       Expression();
14703         jjtree.closeNodeScope(jjtn000, true);
14704         jjtc000 = false;
14705         {if (true) return jjtn000 ;}
14706     } catch (Throwable jjte000) {
14707           if (jjtc000) {
14708             jjtree.clearNodeScope(jjtn000);
14709             jjtc000 = false;
14710           } else {
14711             jjtree.popNode();
14712           }
14713           if (jjte000 instanceof RuntimeException) {
14714             {if (true) throw (RuntimeException)jjte000;}
14715           }
14716           if (jjte000 instanceof ParseException) {
14717             {if (true) throw (ParseException)jjte000;}
14718           }
14719           {if (true) throw (Error)jjte000;}
14720     } finally {
14721           if (jjtc000) {
14722             jjtree.closeNodeScope(jjtn000, true);
14723           }
14724     }
14725     throw new Error("Missing return statement in function");
14726   }
14727 
14728   final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14729  /*@bgen(jjtree) ConditionalCompilationStatement */
14730   ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14731   boolean jjtc000 = true;
14732   jjtree.openNodeScope(jjtn000);
14733     try {
14734       switch (jj_nt.kind) {
14735       case CC_IF:
14736         jj_consume_token(CC_IF);
14737         ConditionalOrExpression();
14738         jj_consume_token(CC_THEN);
14739         label_39:
14740         while (true) {
14741           switch (jj_nt.kind) {
14742           case 5:
14743           case 16:
14744           case 17:
14745           case 21:
14746           case REPLACE:
14747           case DEFINER:
14748           case CURRENT_USER:
14749           case LANGUAGE:
14750           case INLINE:
14751           case ADD:
14752           case AGGREGATE:
14753           case ARRAY:
14754           case AT:
14755           case ATTRIBUTE:
14756           case AUTHID:
14757           case BEGIN:
14758           case BODY:
14759           case BULK:
14760           case BYTE:
14761           case CASCADE:
14762           case CASE:
14763           case CLOSE:
14764           case COALESCE:
14765           case COLLECT:
14766           case COLUMN:
14767           case COMMENT:
14768           case COMMIT:
14769           case CONSTRUCTOR:
14770           case CONTINUE:
14771           case CONVERT:
14772           case CURRENT:
14773           case CURSOR:
14774           case DATA:
14775           case DATE:
14776           case DAY:
14777           case DECLARE:
14778           case DELETE:
14779           case DISABLE:
14780           case EDITIONABLE:
14781           case ELEMENT:
14782           case ENABLE:
14783           case ESCAPE:
14784           case EXCEPT:
14785           case EXCEPTIONS:
14786           case EXECUTE:
14787           case EXIT:
14788           case EXTERNAL:
14789           case EXTENDS:
14790           case EXTRACT:
14791           case FALSE:
14792           case FETCH:
14793           case FINAL:
14794           case FOR:
14795           case FORALL:
14796           case FORCE:
14797           case FUNCTION:
14798           case GLOBAL:
14799           case GOTO:
14800           case HASH:
14801           case HEAP:
14802           case HOUR:
14803           case IF:
14804           case IMMEDIATE:
14805           case INDICES:
14806           case INDEXTYPE:
14807           case INDICATOR:
14808           case INSERT:
14809           case INSTANTIABLE:
14810           case INTERVAL:
14811           case INVALIDATE:
14812           case ISOLATION:
14813           case JAVA:
14814           case LEVEL:
14815           case LIMIT:
14816           case LOCK:
14817           case LOOP:
14818           case MAP:
14819           case MAX:
14820           case MEMBER:
14821           case MERGE:
14822           case MIN:
14823           case MINUTE:
14824           case MLSLABEL:
14825           case MODIFY:
14826           case MOD:
14827           case MONTH:
14828           case NATURAL:
14829           case NEW:
14830           case NEW_DOT:
14831           case NO:
14832           case NONEDITIONABLE:
14833           case NOT:
14834           case NULL:
14835           case NULLIF:
14836           case OBJECT:
14837           case OID:
14838           case OPAQUE:
14839           case OPEN:
14840           case OPERATOR:
14841           case ORGANIZATION:
14842           case OTHERS:
14843           case OVERRIDING:
14844           case PACKAGE:
14845           case PARTITION:
14846           case PIPE:
14847           case PRAGMA:
14848           case PRESERVE:
14849           case PRIVATE:
14850           case PROCEDURE:
14851           case RAISE:
14852           case RANGE:
14853           case RAW:
14854           case REAL:
14855           case RECORD:
14856           case REF:
14857           case RELEASE:
14858           case RELIES_ON:
14859           case RENAME:
14860           case RESULT:
14861           case RETURN:
14862           case RETURNING:
14863           case REVERSE:
14864           case ROLLBACK:
14865           case ROW:
14866           case ROWS:
14867           case ROWID:
14868           case ROWNUM:
14869           case SAVE:
14870           case SAVEPOINT:
14871           case SECOND:
14872           case SELECT:
14873           case SELF:
14874           case SET:
14875           case SPACE:
14876           case SQL:
14877           case SQLCODE:
14878           case SQLERRM:
14879           case STATIC:
14880           case SUBTYPE:
14881           case SUBSTITUTABLE:
14882           case SUCCESSFUL:
14883           case SYSDATE:
14884           case SYS_REFCURSOR:
14885           case TEMPORARY:
14886           case TIME:
14887           case TIMESTAMP:
14888           case TIMEZONE_REGION:
14889           case TIMEZONE_ABBR:
14890           case TIMEZONE_MINUTE:
14891           case TIMEZONE_HOUR:
14892           case TRANSACTION:
14893           case TRUE:
14894           case TYPE:
14895           case UNDER:
14896           case USING:
14897           case WHILE:
14898           case YES:
14899           case SHOW:
14900           case A:
14901           case UPDATE:
14902           case DOUBLE:
14903           case DEC:
14904           case PRECISION:
14905           case INT:
14906           case NUMERIC:
14907           case NCHAR:
14908           case NVARCHAR2:
14909           case STRING:
14910           case UROWID:
14911           case VARRAY:
14912           case VARYING:
14913           case BFILE:
14914           case BLOB:
14915           case CLOB:
14916           case NCLOB:
14917           case YEAR:
14918           case LOCAL:
14919           case WITH:
14920           case ZONE:
14921           case CHARACTER:
14922           case AFTER:
14923           case BEFORE:
14924           case OLD:
14925           case PARENT:
14926           case CC_IF:
14927           case CC_ERROR:
14928           case ANALYZE:
14929           case ASSOCIATE:
14930           case AUDIT:
14931           case COMPOUND:
14932           case DATABASE:
14933           case CALL:
14934           case DDL:
14935           case DISASSOCIATE:
14936           case EACH:
14937           case FOLLOWS:
14938           case LOGOFF:
14939           case LOGON:
14940           case NESTED:
14941           case NOAUDIT:
14942           case SCHEMA:
14943           case SERVERERROR:
14944           case SHUTDOWN:
14945           case STARTUP:
14946           case STATEMENT:
14947           case STATISTICS:
14948           case SUSPEND:
14949           case TRUNCATE:
14950           case WRAPPED:
14951           case LIBRARY:
14952           case NAME:
14953           case STRUCT:
14954           case CONTEXT:
14955           case PARAMETERS:
14956           case LENGTH:
14957           case TDO:
14958           case MAXLEN:
14959           case CHARSETID:
14960           case CHARSETFORM:
14961           case ACCEPT:
14962           case ACCESSIBLE:
14963           case COPY:
14964           case DEFINE:
14965           case DISCONNECT:
14966           case HOST:
14967           case PRINT:
14968           case QUIT:
14969           case REMARK:
14970           case UNDEFINE:
14971           case VARIABLE:
14972           case WHENEVER:
14973           case ATTACH:
14974           case CAST:
14975           case TREAT:
14976           case TRIM:
14977           case LEFT:
14978           case RIGHT:
14979           case BOTH:
14980           case EMPTY:
14981           case MULTISET:
14982           case SUBMULTISET:
14983           case LEADING:
14984           case TRAILING:
14985           case CHAR_CS:
14986           case NCHAR_CS:
14987           case DBTIMEZONE:
14988           case SESSIONTIMEZONE:
14989           case AUTHENTICATED:
14990           case LINK:
14991           case SHARED:
14992           case DIRECTORY:
14993           case USER:
14994           case IDENTIFIER:
14995           case UNSIGNED_NUMERIC_LITERAL:
14996           case CHARACTER_LITERAL:
14997           case STRING_LITERAL:
14998           case QUOTED_LITERAL:
14999             ;
15000             break;
15001           default:
15002             jj_la1[176] = jj_gen;
15003             break label_39;
15004           }
15005           Statement();
15006         }
15007         label_40:
15008         while (true) {
15009           switch (jj_nt.kind) {
15010           case CC_ELSIF:
15011             ;
15012             break;
15013           default:
15014             jj_la1[177] = jj_gen;
15015             break label_40;
15016           }
15017           jj_consume_token(CC_ELSIF);
15018           ConditionalOrExpression();
15019           jj_consume_token(CC_THEN);
15020           label_41:
15021           while (true) {
15022             Statement();
15023             switch (jj_nt.kind) {
15024             case 5:
15025             case 16:
15026             case 17:
15027             case 21:
15028             case REPLACE:
15029             case DEFINER:
15030             case CURRENT_USER:
15031             case LANGUAGE:
15032             case INLINE:
15033             case ADD:
15034             case AGGREGATE:
15035             case ARRAY:
15036             case AT:
15037             case ATTRIBUTE:
15038             case AUTHID:
15039             case BEGIN:
15040             case BODY:
15041             case BULK:
15042             case BYTE:
15043             case CASCADE:
15044             case CASE:
15045             case CLOSE:
15046             case COALESCE:
15047             case COLLECT:
15048             case COLUMN:
15049             case COMMENT:
15050             case COMMIT:
15051             case CONSTRUCTOR:
15052             case CONTINUE:
15053             case CONVERT:
15054             case CURRENT:
15055             case CURSOR:
15056             case DATA:
15057             case DATE:
15058             case DAY:
15059             case DECLARE:
15060             case DELETE:
15061             case DISABLE:
15062             case EDITIONABLE:
15063             case ELEMENT:
15064             case ENABLE:
15065             case ESCAPE:
15066             case EXCEPT:
15067             case EXCEPTIONS:
15068             case EXECUTE:
15069             case EXIT:
15070             case EXTERNAL:
15071             case EXTENDS:
15072             case EXTRACT:
15073             case FALSE:
15074             case FETCH:
15075             case FINAL:
15076             case FOR:
15077             case FORALL:
15078             case FORCE:
15079             case FUNCTION:
15080             case GLOBAL:
15081             case GOTO:
15082             case HASH:
15083             case HEAP:
15084             case HOUR:
15085             case IF:
15086             case IMMEDIATE:
15087             case INDICES:
15088             case INDEXTYPE:
15089             case INDICATOR:
15090             case INSERT:
15091             case INSTANTIABLE:
15092             case INTERVAL:
15093             case INVALIDATE:
15094             case ISOLATION:
15095             case JAVA:
15096             case LEVEL:
15097             case LIMIT:
15098             case LOCK:
15099             case LOOP:
15100             case MAP:
15101             case MAX:
15102             case MEMBER:
15103             case MERGE:
15104             case MIN:
15105             case MINUTE:
15106             case MLSLABEL:
15107             case MODIFY:
15108             case MOD:
15109             case MONTH:
15110             case NATURAL:
15111             case NEW:
15112             case NEW_DOT:
15113             case NO:
15114             case NONEDITIONABLE:
15115             case NOT:
15116             case NULL:
15117             case NULLIF:
15118             case OBJECT:
15119             case OID:
15120             case OPAQUE:
15121             case OPEN:
15122             case OPERATOR:
15123             case ORGANIZATION:
15124             case OTHERS:
15125             case OVERRIDING:
15126             case PACKAGE:
15127             case PARTITION:
15128             case PIPE:
15129             case PRAGMA:
15130             case PRESERVE:
15131             case PRIVATE:
15132             case PROCEDURE:
15133             case RAISE:
15134             case RANGE:
15135             case RAW:
15136             case REAL:
15137             case RECORD:
15138             case REF:
15139             case RELEASE:
15140             case RELIES_ON:
15141             case RENAME:
15142             case RESULT:
15143             case RETURN:
15144             case RETURNING:
15145             case REVERSE:
15146             case ROLLBACK:
15147             case ROW:
15148             case ROWS:
15149             case ROWID:
15150             case ROWNUM:
15151             case SAVE:
15152             case SAVEPOINT:
15153             case SECOND:
15154             case SELECT:
15155             case SELF:
15156             case SET:
15157             case SPACE:
15158             case SQL:
15159             case SQLCODE:
15160             case SQLERRM:
15161             case STATIC:
15162             case SUBTYPE:
15163             case SUBSTITUTABLE:
15164             case SUCCESSFUL:
15165             case SYSDATE:
15166             case SYS_REFCURSOR:
15167             case TEMPORARY:
15168             case TIME:
15169             case TIMESTAMP:
15170             case TIMEZONE_REGION:
15171             case TIMEZONE_ABBR:
15172             case TIMEZONE_MINUTE:
15173             case TIMEZONE_HOUR:
15174             case TRANSACTION:
15175             case TRUE:
15176             case TYPE:
15177             case UNDER:
15178             case USING:
15179             case WHILE:
15180             case YES:
15181             case SHOW:
15182             case A:
15183             case UPDATE:
15184             case DOUBLE:
15185             case DEC:
15186             case PRECISION:
15187             case INT:
15188             case NUMERIC:
15189             case NCHAR:
15190             case NVARCHAR2:
15191             case STRING:
15192             case UROWID:
15193             case VARRAY:
15194             case VARYING:
15195             case BFILE:
15196             case BLOB:
15197             case CLOB:
15198             case NCLOB:
15199             case YEAR:
15200             case LOCAL:
15201             case WITH:
15202             case ZONE:
15203             case CHARACTER:
15204             case AFTER:
15205             case BEFORE:
15206             case OLD:
15207             case PARENT:
15208             case CC_IF:
15209             case CC_ERROR:
15210             case ANALYZE:
15211             case ASSOCIATE:
15212             case AUDIT:
15213             case COMPOUND:
15214             case DATABASE:
15215             case CALL:
15216             case DDL:
15217             case DISASSOCIATE:
15218             case EACH:
15219             case FOLLOWS:
15220             case LOGOFF:
15221             case LOGON:
15222             case NESTED:
15223             case NOAUDIT:
15224             case SCHEMA:
15225             case SERVERERROR:
15226             case SHUTDOWN:
15227             case STARTUP:
15228             case STATEMENT:
15229             case STATISTICS:
15230             case SUSPEND:
15231             case TRUNCATE:
15232             case WRAPPED:
15233             case LIBRARY:
15234             case NAME:
15235             case STRUCT:
15236             case CONTEXT:
15237             case PARAMETERS:
15238             case LENGTH:
15239             case TDO:
15240             case MAXLEN:
15241             case CHARSETID:
15242             case CHARSETFORM:
15243             case ACCEPT:
15244             case ACCESSIBLE:
15245             case COPY:
15246             case DEFINE:
15247             case DISCONNECT:
15248             case HOST:
15249             case PRINT:
15250             case QUIT:
15251             case REMARK:
15252             case UNDEFINE:
15253             case VARIABLE:
15254             case WHENEVER:
15255             case ATTACH:
15256             case CAST:
15257             case TREAT:
15258             case TRIM:
15259             case LEFT:
15260             case RIGHT:
15261             case BOTH:
15262             case EMPTY:
15263             case MULTISET:
15264             case SUBMULTISET:
15265             case LEADING:
15266             case TRAILING:
15267             case CHAR_CS:
15268             case NCHAR_CS:
15269             case DBTIMEZONE:
15270             case SESSIONTIMEZONE:
15271             case AUTHENTICATED:
15272             case LINK:
15273             case SHARED:
15274             case DIRECTORY:
15275             case USER:
15276             case IDENTIFIER:
15277             case UNSIGNED_NUMERIC_LITERAL:
15278             case CHARACTER_LITERAL:
15279             case STRING_LITERAL:
15280             case QUOTED_LITERAL:
15281               ;
15282               break;
15283             default:
15284               jj_la1[178] = jj_gen;
15285               break label_41;
15286             }
15287           }
15288         }
15289         label_42:
15290         while (true) {
15291           switch (jj_nt.kind) {
15292           case CC_ELSE:
15293             ;
15294             break;
15295           default:
15296             jj_la1[179] = jj_gen;
15297             break label_42;
15298           }
15299           jj_consume_token(CC_ELSE);
15300           label_43:
15301           while (true) {
15302             Statement();
15303             switch (jj_nt.kind) {
15304             case 5:
15305             case 16:
15306             case 17:
15307             case 21:
15308             case REPLACE:
15309             case DEFINER:
15310             case CURRENT_USER:
15311             case LANGUAGE:
15312             case INLINE:
15313             case ADD:
15314             case AGGREGATE:
15315             case ARRAY:
15316             case AT:
15317             case ATTRIBUTE:
15318             case AUTHID:
15319             case BEGIN:
15320             case BODY:
15321             case BULK:
15322             case BYTE:
15323             case CASCADE:
15324             case CASE:
15325             case CLOSE:
15326             case COALESCE:
15327             case COLLECT:
15328             case COLUMN:
15329             case COMMENT:
15330             case COMMIT:
15331             case CONSTRUCTOR:
15332             case CONTINUE:
15333             case CONVERT:
15334             case CURRENT:
15335             case CURSOR:
15336             case DATA:
15337             case DATE:
15338             case DAY:
15339             case DECLARE:
15340             case DELETE:
15341             case DISABLE:
15342             case EDITIONABLE:
15343             case ELEMENT:
15344             case ENABLE:
15345             case ESCAPE:
15346             case EXCEPT:
15347             case EXCEPTIONS:
15348             case EXECUTE:
15349             case EXIT:
15350             case EXTERNAL:
15351             case EXTENDS:
15352             case EXTRACT:
15353             case FALSE:
15354             case FETCH:
15355             case FINAL:
15356             case FOR:
15357             case FORALL:
15358             case FORCE:
15359             case FUNCTION:
15360             case GLOBAL:
15361             case GOTO:
15362             case HASH:
15363             case HEAP:
15364             case HOUR:
15365             case IF:
15366             case IMMEDIATE:
15367             case INDICES:
15368             case INDEXTYPE:
15369             case INDICATOR:
15370             case INSERT:
15371             case INSTANTIABLE:
15372             case INTERVAL:
15373             case INVALIDATE:
15374             case ISOLATION:
15375             case JAVA:
15376             case LEVEL:
15377             case LIMIT:
15378             case LOCK:
15379             case LOOP:
15380             case MAP:
15381             case MAX:
15382             case MEMBER:
15383             case MERGE:
15384             case MIN:
15385             case MINUTE:
15386             case MLSLABEL:
15387             case MODIFY:
15388             case MOD:
15389             case MONTH:
15390             case NATURAL:
15391             case NEW:
15392             case NEW_DOT:
15393             case NO:
15394             case NONEDITIONABLE:
15395             case NOT:
15396             case NULL:
15397             case NULLIF:
15398             case OBJECT:
15399             case OID:
15400             case OPAQUE:
15401             case OPEN:
15402             case OPERATOR:
15403             case ORGANIZATION:
15404             case OTHERS:
15405             case OVERRIDING:
15406             case PACKAGE:
15407             case PARTITION:
15408             case PIPE:
15409             case PRAGMA:
15410             case PRESERVE:
15411             case PRIVATE:
15412             case PROCEDURE:
15413             case RAISE:
15414             case RANGE:
15415             case RAW:
15416             case REAL:
15417             case RECORD:
15418             case REF:
15419             case RELEASE:
15420             case RELIES_ON:
15421             case RENAME:
15422             case RESULT:
15423             case RETURN:
15424             case RETURNING:
15425             case REVERSE:
15426             case ROLLBACK:
15427             case ROW:
15428             case ROWS:
15429             case ROWID:
15430             case ROWNUM:
15431             case SAVE:
15432             case SAVEPOINT:
15433             case SECOND:
15434             case SELECT:
15435             case SELF:
15436             case SET:
15437             case SPACE:
15438             case SQL:
15439             case SQLCODE:
15440             case SQLERRM:
15441             case STATIC:
15442             case SUBTYPE:
15443             case SUBSTITUTABLE:
15444             case SUCCESSFUL:
15445             case SYSDATE:
15446             case SYS_REFCURSOR:
15447             case TEMPORARY:
15448             case TIME:
15449             case TIMESTAMP:
15450             case TIMEZONE_REGION:
15451             case TIMEZONE_ABBR:
15452             case TIMEZONE_MINUTE:
15453             case TIMEZONE_HOUR:
15454             case TRANSACTION:
15455             case TRUE:
15456             case TYPE:
15457             case UNDER:
15458             case USING:
15459             case WHILE:
15460             case YES:
15461             case SHOW:
15462             case A:
15463             case UPDATE:
15464             case DOUBLE:
15465             case DEC:
15466             case PRECISION:
15467             case INT:
15468             case NUMERIC:
15469             case NCHAR:
15470             case NVARCHAR2:
15471             case STRING:
15472             case UROWID:
15473             case VARRAY:
15474             case VARYING:
15475             case BFILE:
15476             case BLOB:
15477             case CLOB:
15478             case NCLOB:
15479             case YEAR:
15480             case LOCAL:
15481             case WITH:
15482             case ZONE:
15483             case CHARACTER:
15484             case AFTER:
15485             case BEFORE:
15486             case OLD:
15487             case PARENT:
15488             case CC_IF:
15489             case CC_ERROR:
15490             case ANALYZE:
15491             case ASSOCIATE:
15492             case AUDIT:
15493             case COMPOUND:
15494             case DATABASE:
15495             case CALL:
15496             case DDL:
15497             case DISASSOCIATE:
15498             case EACH:
15499             case FOLLOWS:
15500             case LOGOFF:
15501             case LOGON:
15502             case NESTED:
15503             case NOAUDIT:
15504             case SCHEMA:
15505             case SERVERERROR:
15506             case SHUTDOWN:
15507             case STARTUP:
15508             case STATEMENT:
15509             case STATISTICS:
15510             case SUSPEND:
15511             case TRUNCATE:
15512             case WRAPPED:
15513             case LIBRARY:
15514             case NAME:
15515             case STRUCT:
15516             case CONTEXT:
15517             case PARAMETERS:
15518             case LENGTH:
15519             case TDO:
15520             case MAXLEN:
15521             case CHARSETID:
15522             case CHARSETFORM:
15523             case ACCEPT:
15524             case ACCESSIBLE:
15525             case COPY:
15526             case DEFINE:
15527             case DISCONNECT:
15528             case HOST:
15529             case PRINT:
15530             case QUIT:
15531             case REMARK:
15532             case UNDEFINE:
15533             case VARIABLE:
15534             case WHENEVER:
15535             case ATTACH:
15536             case CAST:
15537             case TREAT:
15538             case TRIM:
15539             case LEFT:
15540             case RIGHT:
15541             case BOTH:
15542             case EMPTY:
15543             case MULTISET:
15544             case SUBMULTISET:
15545             case LEADING:
15546             case TRAILING:
15547             case CHAR_CS:
15548             case NCHAR_CS:
15549             case DBTIMEZONE:
15550             case SESSIONTIMEZONE:
15551             case AUTHENTICATED:
15552             case LINK:
15553             case SHARED:
15554             case DIRECTORY:
15555             case USER:
15556             case IDENTIFIER:
15557             case UNSIGNED_NUMERIC_LITERAL:
15558             case CHARACTER_LITERAL:
15559             case STRING_LITERAL:
15560             case QUOTED_LITERAL:
15561               ;
15562               break;
15563             default:
15564               jj_la1[180] = jj_gen;
15565               break label_43;
15566             }
15567           }
15568         }
15569         jj_consume_token(CC_END);
15570         break;
15571       case CC_ERROR:
15572         jj_consume_token(CC_ERROR);
15573         Expression();
15574         jj_consume_token(CC_END);
15575         break;
15576       default:
15577         jj_la1[181] = jj_gen;
15578         jj_consume_token(-1);
15579         throw new ParseException();
15580       }
15581         jjtree.closeNodeScope(jjtn000, true);
15582         jjtc000 = false;
15583         {if (true) return jjtn000 ;}
15584     } catch (Throwable jjte000) {
15585           if (jjtc000) {
15586             jjtree.clearNodeScope(jjtn000);
15587             jjtc000 = false;
15588           } else {
15589             jjtree.popNode();
15590           }
15591           if (jjte000 instanceof RuntimeException) {
15592             {if (true) throw (RuntimeException)jjte000;}
15593           }
15594           if (jjte000 instanceof ParseException) {
15595             {if (true) throw (ParseException)jjte000;}
15596           }
15597           {if (true) throw (Error)jjte000;}
15598     } finally {
15599           if (jjtc000) {
15600             jjtree.closeNodeScope(jjtn000, true);
15601           }
15602     }
15603     throw new Error("Missing return statement in function");
15604   }
15605 
15606   final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15607  /*@bgen(jjtree) SubTypeDefinition */
15608         ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15609         boolean jjtc000 = true;
15610         jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15611         Token collection = null, collection2 = null;
15612         PLSQLNode name = null;
15613         PLSQLNode startElement = null, endElement = null;
15614         PLSQLNode baseType = null, returnType = null, indexBy = null ;
15615         int lastField = 0;
15616     try {
15617       switch (jj_nt.kind) {
15618       case SUBTYPE:
15619         jj_consume_token(SUBTYPE);
15620         name = QualifiedID();
15621         jj_consume_token(IS);
15622         Datatype();
15623         switch (jj_nt.kind) {
15624         case 5:
15625         case RANGE:
15626           switch (jj_nt.kind) {
15627           case 5:
15628             jj_consume_token(5);
15629             jj_consume_token(IDENTIFIER);
15630             jj_consume_token(7);
15631             break;
15632           case RANGE:
15633             jj_consume_token(RANGE);
15634             UnaryExpression(true);
15635             jj_consume_token(12);
15636             UnaryExpression(true);
15637             break;
15638           default:
15639             jj_la1[182] = jj_gen;
15640             jj_consume_token(-1);
15641             throw new ParseException();
15642           }
15643           break;
15644         default:
15645           jj_la1[183] = jj_gen;
15646           ;
15647         }
15648         switch (jj_nt.kind) {
15649         case NOT:
15650           jj_consume_token(NOT);
15651           jj_consume_token(NULL);
15652           break;
15653         default:
15654           jj_la1[184] = jj_gen;
15655           ;
15656         }
15657         break;
15658       case TYPE:
15659         jj_consume_token(TYPE);
15660         name = QualifiedID();
15661         switch (jj_nt.kind) {
15662         case IS:
15663           jj_consume_token(IS);
15664           break;
15665         case AS:
15666           jj_consume_token(AS);
15667           break;
15668         default:
15669           jj_la1[185] = jj_gen;
15670           jj_consume_token(-1);
15671           throw new ParseException();
15672         }
15673         if (jj_2_44(2)) {
15674           jj_consume_token(NEW);
15675           switch (jj_nt.kind) {
15676           case CHAR_BASE:
15677             jj_consume_token(CHAR_BASE);
15678             break;
15679           case DATE_BASE:
15680             jj_consume_token(DATE_BASE);
15681             break;
15682           case CLOB_BASE:
15683             jj_consume_token(CLOB_BASE);
15684             break;
15685           case BLOB_BASE:
15686             jj_consume_token(BLOB_BASE);
15687             break;
15688           case BFILE_BASE:
15689             jj_consume_token(BFILE_BASE);
15690             break;
15691           case NUMBER_BASE:
15692             jj_consume_token(NUMBER_BASE);
15693             break;
15694           default:
15695             jj_la1[186] = jj_gen;
15696             jj_consume_token(-1);
15697             throw new ParseException();
15698           }
15699         } else {
15700           switch (jj_nt.kind) {
15701           case OBJECT:
15702             jj_consume_token(OBJECT);
15703             jj_consume_token(5);
15704             FieldDeclaration();
15705             label_44:
15706             while (true) {
15707               switch (jj_nt.kind) {
15708               case 6:
15709                 ;
15710                 break;
15711               default:
15712                 jj_la1[187] = jj_gen;
15713                 break label_44;
15714               }
15715               jj_consume_token(6);
15716               FieldDeclaration();
15717             }
15718             jj_consume_token(7);
15719             break;
15720           case RECORD:
15721             jj_consume_token(RECORD);
15722             jj_consume_token(5);
15723             FieldDeclaration();
15724             label_45:
15725             while (true) {
15726               switch (jj_nt.kind) {
15727               case 6:
15728                 ;
15729                 break;
15730               default:
15731                 jj_la1[188] = jj_gen;
15732                 break label_45;
15733               }
15734               jj_consume_token(6);
15735               FieldDeclaration();
15736             }
15737             jj_consume_token(7);
15738             break;
15739           case TABLE:
15740           case VARRAY:
15741           case VARYING:
15742             switch (jj_nt.kind) {
15743             case TABLE:
15744               jj_consume_token(TABLE);
15745               break;
15746             case VARRAY:
15747               jj_consume_token(VARRAY);
15748               break;
15749             case VARYING:
15750               jj_consume_token(VARYING);
15751               jj_consume_token(ARRAY);
15752               break;
15753             default:
15754               jj_la1[189] = jj_gen;
15755               jj_consume_token(-1);
15756               throw new ParseException();
15757             }
15758             switch (jj_nt.kind) {
15759             case 5:
15760               jj_consume_token(5);
15761               NumericLiteral();
15762               jj_consume_token(7);
15763               break;
15764             default:
15765               jj_la1[190] = jj_gen;
15766               ;
15767             }
15768             jj_consume_token(OF);
15769             Datatype();
15770             switch (jj_nt.kind) {
15771             case NOT:
15772               jj_consume_token(NOT);
15773               jj_consume_token(NULL);
15774               break;
15775             default:
15776               jj_la1[191] = jj_gen;
15777               ;
15778             }
15779             switch (jj_nt.kind) {
15780             case INDEX:
15781               jj_consume_token(INDEX);
15782               jj_consume_token(BY);
15783               Datatype();
15784               break;
15785             default:
15786               jj_la1[192] = jj_gen;
15787               ;
15788             }
15789             break;
15790           case REF:
15791             jj_consume_token(REF);
15792             jj_consume_token(CURSOR);
15793             switch (jj_nt.kind) {
15794             case RETURN:
15795               jj_consume_token(RETURN);
15796               Datatype();
15797               break;
15798             default:
15799               jj_la1[193] = jj_gen;
15800               ;
15801             }
15802             break;
15803           case 5:
15804             jj_consume_token(5);
15805             Expression();
15806             label_46:
15807             while (true) {
15808               switch (jj_nt.kind) {
15809               case 6:
15810                 ;
15811                 break;
15812               default:
15813                 jj_la1[194] = jj_gen;
15814                 break label_46;
15815               }
15816               jj_consume_token(6);
15817               Expression();
15818             }
15819             jj_consume_token(7);
15820             break;
15821           case REPLACE:
15822           case DEFINER:
15823           case CURRENT_USER:
15824           case LANGUAGE:
15825           case INLINE:
15826           case ADD:
15827           case AGGREGATE:
15828           case ARRAY:
15829           case AT:
15830           case ATTRIBUTE:
15831           case AUTHID:
15832           case BINARY_INTEGER:
15833           case BODY:
15834           case BOOLEAN:
15835           case BULK:
15836           case BYTE:
15837           case CASCADE:
15838           case CHAR:
15839           case CHAR_BASE:
15840           case CLOSE:
15841           case COALESCE:
15842           case COLLECT:
15843           case COLUMN:
15844           case COMMENT:
15845           case COMMIT:
15846           case CONSTRUCTOR:
15847           case CONTINUE:
15848           case CONVERT:
15849           case CURRENT:
15850           case CURSOR:
15851           case DATA:
15852           case DATE:
15853           case DAY:
15854           case DECIMAL:
15855           case DISABLE:
15856           case EDITIONABLE:
15857           case ELEMENT:
15858           case ENABLE:
15859           case ESCAPE:
15860           case EXCEPT:
15861           case EXCEPTIONS:
15862           case EXIT:
15863           case EXTERNAL:
15864           case EXTENDS:
15865           case EXTRACT:
15866           case FALSE:
15867           case FINAL:
15868           case FLOAT:
15869           case FORCE:
15870           case FUNCTION:
15871           case GLOBAL:
15872           case HASH:
15873           case HEAP:
15874           case HOUR:
15875           case IMMEDIATE:
15876           case INDICES:
15877           case INDEXTYPE:
15878           case INDICATOR:
15879           case INSTANTIABLE:
15880           case INTEGER:
15881           case INTERVAL:
15882           case INVALIDATE:
15883           case ISOLATION:
15884           case JAVA:
15885           case LEVEL:
15886           case LIMIT:
15887           case LONG:
15888           case LOOP:
15889           case MAP:
15890           case MAX:
15891           case MEMBER:
15892           case MERGE:
15893           case MIN:
15894           case MINUTE:
15895           case MLSLABEL:
15896           case MODIFY:
15897           case MOD:
15898           case MONTH:
15899           case NATURAL:
15900           case NATURALN:
15901           case NEW:
15902           case NO:
15903           case NONEDITIONABLE:
15904           case NULLIF:
15905           case NUMBER:
15906           case BFILE_BASE:
15907           case BLOB_BASE:
15908           case CLOB_BASE:
15909           case DATE_BASE:
15910           case NUMBER_BASE:
15911           case OID:
15912           case OPAQUE:
15913           case OPEN:
15914           case OPERATOR:
15915           case ORGANIZATION:
15916           case OTHERS:
15917           case OVERRIDING:
15918           case PACKAGE:
15919           case PARTITION:
15920           case PLS_INTEGER:
15921           case POSITIVE:
15922           case POSITIVEN:
15923           case PRESERVE:
15924           case PRIVATE:
15925           case PROCEDURE:
15926           case RANGE:
15927           case RAW:
15928           case REAL:
15929           case RELEASE:
15930           case RELIES_ON:
15931           case RENAME:
15932           case RESULT:
15933           case RETURN:
15934           case RETURNING:
15935           case REVERSE:
15936           case ROLLBACK:
15937           case ROW:
15938           case ROWS:
15939           case ROWID:
15940           case ROWNUM:
15941           case SAVE:
15942           case SAVEPOINT:
15943           case SECOND:
15944           case SELF:
15945           case SET:
15946           case SMALLINT:
15947           case SPACE:
15948           case SQL:
15949           case SQLCODE:
15950           case SQLERRM:
15951           case STATIC:
15952           case SUBTYPE:
15953           case SUBSTITUTABLE:
15954           case SUCCESSFUL:
15955           case SYSDATE:
15956           case SYS_REFCURSOR:
15957           case TEMPORARY:
15958           case TIME:
15959           case TIMESTAMP:
15960           case TIMEZONE_REGION:
15961           case TIMEZONE_ABBR:
15962           case TIMEZONE_MINUTE:
15963           case TIMEZONE_HOUR:
15964           case TRANSACTION:
15965           case TRUE:
15966           case TYPE:
15967           case UNDER:
15968           case USING:
15969           case YES:
15970           case SHOW:
15971           case A:
15972           case VARCHAR:
15973           case VARCHAR2:
15974           case DOUBLE:
15975           case DEC:
15976           case PRECISION:
15977           case INT:
15978           case NUMERIC:
15979           case SIGNTYPE:
15980           case NCHAR:
15981           case NVARCHAR2:
15982           case STRING:
15983           case UROWID:
15984           case BFILE:
15985           case BLOB:
15986           case CLOB:
15987           case NCLOB:
15988           case YEAR:
15989           case LOCAL:
15990           case ZONE:
15991           case CHARACTER:
15992           case AFTER:
15993           case BEFORE:
15994           case OLD:
15995           case PARENT:
15996           case CC_IF:
15997           case ANALYZE:
15998           case ASSOCIATE:
15999           case AUDIT:
16000           case COMPOUND:
16001           case DATABASE:
16002           case CALL:
16003           case DDL:
16004           case DISASSOCIATE:
16005           case EACH:
16006           case FOLLOWS:
16007           case LOGOFF:
16008           case LOGON:
16009           case NESTED:
16010           case NOAUDIT:
16011           case SCHEMA:
16012           case SERVERERROR:
16013           case SHUTDOWN:
16014           case STARTUP:
16015           case STATEMENT:
16016           case STATISTICS:
16017           case SUSPEND:
16018           case TRUNCATE:
16019           case WRAPPED:
16020           case LIBRARY:
16021           case NAME:
16022           case STRUCT:
16023           case CONTEXT:
16024           case PARAMETERS:
16025           case LENGTH:
16026           case TDO:
16027           case MAXLEN:
16028           case CHARSETID:
16029           case CHARSETFORM:
16030           case ACCEPT:
16031           case ACCESSIBLE:
16032           case COPY:
16033           case DEFINE:
16034           case DISCONNECT:
16035           case HOST:
16036           case PRINT:
16037           case QUIT:
16038           case REMARK:
16039           case UNDEFINE:
16040           case VARIABLE:
16041           case WHENEVER:
16042           case ATTACH:
16043           case CAST:
16044           case TREAT:
16045           case TRIM:
16046           case LEFT:
16047           case RIGHT:
16048           case BOTH:
16049           case EMPTY:
16050           case MULTISET:
16051           case SUBMULTISET:
16052           case LEADING:
16053           case TRAILING:
16054           case CHAR_CS:
16055           case NCHAR_CS:
16056           case DBTIMEZONE:
16057           case SESSIONTIMEZONE:
16058           case AUTHENTICATED:
16059           case LINK:
16060           case SHARED:
16061           case DIRECTORY:
16062           case USER:
16063           case IDENTIFIER:
16064           case QUOTED_LITERAL:
16065             Datatype();
16066             break;
16067           default:
16068             jj_la1[195] = jj_gen;
16069             jj_consume_token(-1);
16070             throw new ParseException();
16071           }
16072         }
16073         break;
16074       default:
16075         jj_la1[196] = jj_gen;
16076         jj_consume_token(-1);
16077         throw new ParseException();
16078       }
16079       jj_consume_token(4);
16080         jjtree.closeNodeScope(jjtn000, true);
16081         jjtc000 = false;
16082         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16083     } catch (Throwable jjte000) {
16084           if (jjtc000) {
16085             jjtree.clearNodeScope(jjtn000);
16086             jjtc000 = false;
16087           } else {
16088             jjtree.popNode();
16089           }
16090           if (jjte000 instanceof RuntimeException) {
16091             {if (true) throw (RuntimeException)jjte000;}
16092           }
16093           if (jjte000 instanceof ParseException) {
16094             {if (true) throw (ParseException)jjte000;}
16095           }
16096           {if (true) throw (Error)jjte000;}
16097     } finally {
16098           if (jjtc000) {
16099             jjtree.closeNodeScope(jjtn000, true);
16100           }
16101     }
16102     throw new Error("Missing return statement in function");
16103   }
16104 
16105   final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16106  /*@bgen(jjtree) FieldDeclaration */
16107         ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16108         boolean jjtc000 = true;
16109         jjtree.openNodeScope(jjtn000);PLSQLNode name;
16110         PLSQLNode dataType;
16111         PLSQLNode defaultValue = null;
16112     try {
16113       name = ID();
16114       Datatype();
16115       switch (jj_nt.kind) {
16116       case NOT:
16117       case NULL:
16118         switch (jj_nt.kind) {
16119         case NOT:
16120           jj_consume_token(NOT);
16121           break;
16122         default:
16123           jj_la1[197] = jj_gen;
16124           ;
16125         }
16126         jj_consume_token(NULL);
16127         break;
16128       default:
16129         jj_la1[198] = jj_gen;
16130         ;
16131       }
16132       switch (jj_nt.kind) {
16133       case 9:
16134       case _DEFAULT:
16135         switch (jj_nt.kind) {
16136         case 9:
16137           jj_consume_token(9);
16138           jj_consume_token(10);
16139           break;
16140         case _DEFAULT:
16141           jj_consume_token(_DEFAULT);
16142           break;
16143         default:
16144           jj_la1[199] = jj_gen;
16145           jj_consume_token(-1);
16146           throw new ParseException();
16147         }
16148         Expression();
16149         break;
16150       default:
16151         jj_la1[200] = jj_gen;
16152         ;
16153       }
16154         jjtree.closeNodeScope(jjtn000, true);
16155         jjtc000 = false;
16156         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16157     } catch (Throwable jjte000) {
16158           if (jjtc000) {
16159             jjtree.clearNodeScope(jjtn000);
16160             jjtc000 = false;
16161           } else {
16162             jjtree.popNode();
16163           }
16164           if (jjte000 instanceof RuntimeException) {
16165             {if (true) throw (RuntimeException)jjte000;}
16166           }
16167           if (jjte000 instanceof ParseException) {
16168             {if (true) throw (ParseException)jjte000;}
16169           }
16170           {if (true) throw (Error)jjte000;}
16171     } finally {
16172           if (jjtc000) {
16173             jjtree.closeNodeScope(jjtn000, true);
16174           }
16175     }
16176     throw new Error("Missing return statement in function");
16177   }
16178 
16179   final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16180                                                           /*@bgen(jjtree) CollectionTypeDefinition */
16181                                                           ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16182                                                           boolean jjtc000 = true;
16183                                                           jjtree.openNodeScope(jjtn000);Token t = null ;
16184     try {
16185       t = jj_consume_token(IDENTIFIER);
16186                                                                                                   jjtree.closeNodeScope(jjtn000, true);
16187                                                                                                   jjtc000 = false;
16188                                                                                                   jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16189     } finally {
16190                                                                                  if (jjtc000) {
16191                                                                                    jjtree.closeNodeScope(jjtn000, true);
16192                                                                                  }
16193     }
16194     throw new Error("Missing return statement in function");
16195   }
16196 
16197   final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16198                                                     /*@bgen(jjtree) CollectionDeclaration */
16199                                                     ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16200                                                     boolean jjtc000 = true;
16201                                                     jjtree.openNodeScope(jjtn000);Token t = null ;
16202     try {
16203       t = jj_consume_token(IDENTIFIER);
16204                                                                                             jjtree.closeNodeScope(jjtn000, true);
16205                                                                                             jjtc000 = false;
16206                                                                                             jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16207     } finally {
16208                                                                            if (jjtc000) {
16209                                                                              jjtree.closeNodeScope(jjtn000, true);
16210                                                                            }
16211     }
16212     throw new Error("Missing return statement in function");
16213   }
16214 
16215   final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16216                                             /*@bgen(jjtree) ObjectDeclaration */
16217                                             ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16218                                             boolean jjtc000 = true;
16219                                             jjtree.openNodeScope(jjtn000);Token t = null ;
16220     try {
16221       t = jj_consume_token(IDENTIFIER);
16222                                                                                     jjtree.closeNodeScope(jjtn000, true);
16223                                                                                     jjtc000 = false;
16224                                                                                     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16225     } finally {
16226                                                                    if (jjtc000) {
16227                                                                      jjtree.closeNodeScope(jjtn000, true);
16228                                                                    }
16229     }
16230     throw new Error("Missing return statement in function");
16231   }
16232 
16233 /** Java stored procedure, external function*/
16234   final public ASTCallSpecTail CallSpecTail() throws ParseException {
16235                                   /*@bgen(jjtree) CallSpecTail */
16236   ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16237   boolean jjtc000 = true;
16238   jjtree.openNodeScope(jjtn000);
16239     try {
16240       switch (jj_nt.kind) {
16241       case EXTERNAL:
16242         jj_consume_token(EXTERNAL);
16243         break;
16244       case LANGUAGE:
16245         jj_consume_token(LANGUAGE);
16246         switch (jj_nt.kind) {
16247         case IDENTIFIER:
16248           jj_consume_token(IDENTIFIER);
16249           break;
16250         case JAVA:
16251           jj_consume_token(JAVA);
16252           break;
16253         default:
16254           jj_la1[201] = jj_gen;
16255           jj_consume_token(-1);
16256           throw new ParseException();
16257         }
16258         break;
16259       default:
16260         jj_la1[202] = jj_gen;
16261         jj_consume_token(-1);
16262         throw new ParseException();
16263       }
16264       label_47:
16265       while (true) {
16266         switch (jj_nt.kind) {
16267         case WITH:
16268         case LIBRARY:
16269         case NAME:
16270         case PARAMETERS:
16271           ;
16272           break;
16273         default:
16274           jj_la1[203] = jj_gen;
16275           break label_47;
16276         }
16277         switch (jj_nt.kind) {
16278         case LIBRARY:
16279           jj_consume_token(LIBRARY);
16280           switch (jj_nt.kind) {
16281           case IDENTIFIER:
16282             jj_consume_token(IDENTIFIER);
16283             break;
16284           case QUOTED_LITERAL:
16285             jj_consume_token(QUOTED_LITERAL);
16286             break;
16287           case STRING_LITERAL:
16288             StringLiteral();
16289             break;
16290           default:
16291             jj_la1[204] = jj_gen;
16292             jj_consume_token(-1);
16293             throw new ParseException();
16294           }
16295           switch (jj_nt.kind) {
16296           case 3:
16297             jj_consume_token(3);
16298             switch (jj_nt.kind) {
16299             case IDENTIFIER:
16300               jj_consume_token(IDENTIFIER);
16301               break;
16302             case QUOTED_LITERAL:
16303               jj_consume_token(QUOTED_LITERAL);
16304               break;
16305             case STRING_LITERAL:
16306               StringLiteral();
16307               break;
16308             default:
16309               jj_la1[205] = jj_gen;
16310               jj_consume_token(-1);
16311               throw new ParseException();
16312             }
16313             break;
16314           default:
16315             jj_la1[206] = jj_gen;
16316             ;
16317           }
16318           break;
16319         case NAME:
16320           jj_consume_token(NAME);
16321           switch (jj_nt.kind) {
16322           case IDENTIFIER:
16323             jj_consume_token(IDENTIFIER);
16324             break;
16325           case QUOTED_LITERAL:
16326             jj_consume_token(QUOTED_LITERAL);
16327             break;
16328           case STRING_LITERAL:
16329             StringLiteral();
16330             break;
16331           default:
16332             jj_la1[207] = jj_gen;
16333             jj_consume_token(-1);
16334             throw new ParseException();
16335           }
16336           break;
16337         case WITH:
16338           jj_consume_token(WITH);
16339           jj_consume_token(CONTEXT);
16340           break;
16341         case PARAMETERS:
16342           jj_consume_token(PARAMETERS);
16343           SkipPastNextOccurrence(")");
16344           break;
16345         default:
16346           jj_la1[208] = jj_gen;
16347           jj_consume_token(-1);
16348           throw new ParseException();
16349         }
16350       }
16351         jjtree.closeNodeScope(jjtn000, true);
16352         jjtc000 = false;
16353         {if (true) return jjtn000 ;}
16354     } catch (Throwable jjte000) {
16355           if (jjtc000) {
16356             jjtree.clearNodeScope(jjtn000);
16357             jjtc000 = false;
16358           } else {
16359             jjtree.popNode();
16360           }
16361           if (jjte000 instanceof RuntimeException) {
16362             {if (true) throw (RuntimeException)jjte000;}
16363           }
16364           if (jjte000 instanceof ParseException) {
16365             {if (true) throw (ParseException)jjte000;}
16366           }
16367           {if (true) throw (Error)jjte000;}
16368     } finally {
16369           if (jjtc000) {
16370             jjtree.closeNodeScope(jjtn000, true);
16371           }
16372     }
16373     throw new Error("Missing return statement in function");
16374   }
16375 
16376 /** Cursor (common part of specification and body) */
16377   final public ASTCursorUnit CursorUnit() throws ParseException {
16378  /*@bgen(jjtree) CursorUnit */
16379  ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16380  boolean jjtc000 = true;
16381  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16382     try {
16383       jj_consume_token(CURSOR);
16384       simpleNode = ID();
16385       switch (jj_nt.kind) {
16386       case 5:
16387         FormalParameters();
16388         break;
16389       default:
16390         jj_la1[209] = jj_gen;
16391         ;
16392       }
16393       switch (jj_nt.kind) {
16394       case RETURN:
16395         jj_consume_token(RETURN);
16396         Datatype();
16397         break;
16398       default:
16399         jj_la1[210] = jj_gen;
16400         ;
16401       }
16402       switch (jj_nt.kind) {
16403       case IS:
16404         jj_consume_token(IS);
16405         label_48:
16406         while (true) {
16407           switch (jj_nt.kind) {
16408           case 5:
16409             ;
16410             break;
16411           default:
16412             jj_la1[211] = jj_gen;
16413             break label_48;
16414           }
16415           jj_consume_token(5);
16416         }
16417         SqlStatement(null,";");
16418         break;
16419       default:
16420         jj_la1[212] = jj_gen;
16421         ;
16422       }
16423       jj_consume_token(4);
16424         jjtree.closeNodeScope(jjtn000, true);
16425         jjtc000 = false;
16426         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
16427     } catch (Throwable jjte000) {
16428           if (jjtc000) {
16429             jjtree.clearNodeScope(jjtn000);
16430             jjtc000 = false;
16431           } else {
16432             jjtree.popNode();
16433           }
16434           if (jjte000 instanceof RuntimeException) {
16435             {if (true) throw (RuntimeException)jjte000;}
16436           }
16437           if (jjte000 instanceof ParseException) {
16438             {if (true) throw (ParseException)jjte000;}
16439           }
16440           {if (true) throw (Error)jjte000;}
16441     } finally {
16442           if (jjtc000) {
16443             jjtree.closeNodeScope(jjtn000, true);
16444           }
16445     }
16446     throw new Error("Missing return statement in function");
16447   }
16448 
16449   final public ASTCursorSpecification CursorSpecification() throws ParseException {
16450                                                  /*@bgen(jjtree) CursorSpecification */
16451   ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16452   boolean jjtc000 = true;
16453   jjtree.openNodeScope(jjtn000);
16454     try {
16455       CursorUnit();
16456         jjtree.closeNodeScope(jjtn000, true);
16457         jjtc000 = false;
16458         {if (true) return jjtn000 ;}
16459     } catch (Throwable jjte000) {
16460           if (jjtc000) {
16461             jjtree.clearNodeScope(jjtn000);
16462             jjtc000 = false;
16463           } else {
16464             jjtree.popNode();
16465           }
16466           if (jjte000 instanceof RuntimeException) {
16467             {if (true) throw (RuntimeException)jjte000;}
16468           }
16469           if (jjte000 instanceof ParseException) {
16470             {if (true) throw (ParseException)jjte000;}
16471           }
16472           {if (true) throw (Error)jjte000;}
16473     } finally {
16474           if (jjtc000) {
16475             jjtree.closeNodeScope(jjtn000, true);
16476           }
16477     }
16478     throw new Error("Missing return statement in function");
16479   }
16480 
16481   final public ASTCursorBody CursorBody() throws ParseException {
16482                                /*@bgen(jjtree) CursorBody */
16483   ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16484   boolean jjtc000 = true;
16485   jjtree.openNodeScope(jjtn000);
16486     try {
16487       CursorUnit();
16488         jjtree.closeNodeScope(jjtn000, true);
16489         jjtc000 = false;
16490         {if (true) return jjtn000 ;}
16491     } catch (Throwable jjte000) {
16492           if (jjtc000) {
16493             jjtree.clearNodeScope(jjtn000);
16494             jjtc000 = false;
16495           } else {
16496             jjtree.popNode();
16497           }
16498           if (jjte000 instanceof RuntimeException) {
16499             {if (true) throw (RuntimeException)jjte000;}
16500           }
16501           if (jjte000 instanceof ParseException) {
16502             {if (true) throw (ParseException)jjte000;}
16503           }
16504           {if (true) throw (Error)jjte000;}
16505     } finally {
16506           if (jjtc000) {
16507             jjtree.closeNodeScope(jjtn000, true);
16508           }
16509     }
16510     throw new Error("Missing return statement in function");
16511   }
16512 
16513 // ============================================================================
16514 // E X P R E S S I O N S
16515 // ============================================================================
16516 
16517 /*
16518 String expression() :
16519 {}
16520 {
16521 	"test"
16522 	{ return ""; }
16523 }
16524 */
16525   final public ASTExpression Expression() throws ParseException {
16526  /*@bgen(jjtree) Expression */
16527   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16528   boolean jjtc000 = true;
16529   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16530   StringBuilder sb = new StringBuilder() ;
16531     try {
16532       if (jj_2_45(2147483647)) {
16533         simpleNode = Assignment();
16534                                                                               sb.append(simpleNode.getImage());
16535       } else {
16536         switch (jj_nt.kind) {
16537         case 5:
16538         case 16:
16539         case 17:
16540         case REPLACE:
16541         case DEFINER:
16542         case CURRENT_USER:
16543         case LANGUAGE:
16544         case INLINE:
16545         case ADD:
16546         case AGGREGATE:
16547         case ARRAY:
16548         case AT:
16549         case ATTRIBUTE:
16550         case AUTHID:
16551         case BODY:
16552         case BULK:
16553         case BYTE:
16554         case CASCADE:
16555         case CASE:
16556         case CLOSE:
16557         case COALESCE:
16558         case COLLECT:
16559         case COLUMN:
16560         case COMMENT:
16561         case COMMIT:
16562         case CONSTRUCTOR:
16563         case CONTINUE:
16564         case CONVERT:
16565         case CURRENT:
16566         case CURSOR:
16567         case DATA:
16568         case DATE:
16569         case DAY:
16570         case DISABLE:
16571         case EDITIONABLE:
16572         case ELEMENT:
16573         case ENABLE:
16574         case ESCAPE:
16575         case EXCEPT:
16576         case EXCEPTIONS:
16577         case EXIT:
16578         case EXTERNAL:
16579         case EXTENDS:
16580         case EXTRACT:
16581         case FALSE:
16582         case FINAL:
16583         case FORCE:
16584         case FUNCTION:
16585         case GLOBAL:
16586         case HASH:
16587         case HEAP:
16588         case HOUR:
16589         case IMMEDIATE:
16590         case INDICES:
16591         case INDEXTYPE:
16592         case INDICATOR:
16593         case INSTANTIABLE:
16594         case INTERVAL:
16595         case INVALIDATE:
16596         case ISOLATION:
16597         case JAVA:
16598         case LEVEL:
16599         case LIMIT:
16600         case LOOP:
16601         case MAP:
16602         case MAX:
16603         case MEMBER:
16604         case MERGE:
16605         case MIN:
16606         case MINUTE:
16607         case MLSLABEL:
16608         case MODIFY:
16609         case MOD:
16610         case MONTH:
16611         case NATURAL:
16612         case NEW:
16613         case NEW_DOT:
16614         case NO:
16615         case NONEDITIONABLE:
16616         case NOT:
16617         case NULL:
16618         case NULLIF:
16619         case OBJECT:
16620         case OID:
16621         case OPAQUE:
16622         case OPEN:
16623         case OPERATOR:
16624         case ORGANIZATION:
16625         case OTHERS:
16626         case OVERRIDING:
16627         case PACKAGE:
16628         case PARTITION:
16629         case PRESERVE:
16630         case PRIVATE:
16631         case PROCEDURE:
16632         case RANGE:
16633         case RAW:
16634         case REAL:
16635         case RECORD:
16636         case REF:
16637         case RELEASE:
16638         case RELIES_ON:
16639         case RENAME:
16640         case RESULT:
16641         case RETURN:
16642         case RETURNING:
16643         case REVERSE:
16644         case ROLLBACK:
16645         case ROW:
16646         case ROWS:
16647         case ROWID:
16648         case ROWNUM:
16649         case SAVE:
16650         case SAVEPOINT:
16651         case SECOND:
16652         case SELECT:
16653         case SELF:
16654         case SET:
16655         case SPACE:
16656         case SQL:
16657         case SQLCODE:
16658         case SQLERRM:
16659         case STATIC:
16660         case SUBTYPE:
16661         case SUBSTITUTABLE:
16662         case SUCCESSFUL:
16663         case SYSDATE:
16664         case SYS_REFCURSOR:
16665         case TEMPORARY:
16666         case TIME:
16667         case TIMESTAMP:
16668         case TIMEZONE_REGION:
16669         case TIMEZONE_ABBR:
16670         case TIMEZONE_MINUTE:
16671         case TIMEZONE_HOUR:
16672         case TRANSACTION:
16673         case TRUE:
16674         case TYPE:
16675         case UNDER:
16676         case USING:
16677         case YES:
16678         case SHOW:
16679         case A:
16680         case DOUBLE:
16681         case DEC:
16682         case PRECISION:
16683         case INT:
16684         case NUMERIC:
16685         case NCHAR:
16686         case NVARCHAR2:
16687         case STRING:
16688         case UROWID:
16689         case VARRAY:
16690         case VARYING:
16691         case BFILE:
16692         case BLOB:
16693         case CLOB:
16694         case NCLOB:
16695         case YEAR:
16696         case LOCAL:
16697         case WITH:
16698         case ZONE:
16699         case CHARACTER:
16700         case AFTER:
16701         case BEFORE:
16702         case OLD:
16703         case PARENT:
16704         case ANALYZE:
16705         case ASSOCIATE:
16706         case AUDIT:
16707         case COMPOUND:
16708         case DATABASE:
16709         case CALL:
16710         case DDL:
16711         case DISASSOCIATE:
16712         case EACH:
16713         case FOLLOWS:
16714         case LOGOFF:
16715         case LOGON:
16716         case NESTED:
16717         case NOAUDIT:
16718         case SCHEMA:
16719         case SERVERERROR:
16720         case SHUTDOWN:
16721         case STARTUP:
16722         case STATEMENT:
16723         case STATISTICS:
16724         case SUSPEND:
16725         case TRUNCATE:
16726         case WRAPPED:
16727         case LIBRARY:
16728         case NAME:
16729         case STRUCT:
16730         case CONTEXT:
16731         case PARAMETERS:
16732         case LENGTH:
16733         case TDO:
16734         case MAXLEN:
16735         case CHARSETID:
16736         case CHARSETFORM:
16737         case ACCEPT:
16738         case ACCESSIBLE:
16739         case COPY:
16740         case DEFINE:
16741         case DISCONNECT:
16742         case HOST:
16743         case PRINT:
16744         case QUIT:
16745         case REMARK:
16746         case UNDEFINE:
16747         case VARIABLE:
16748         case WHENEVER:
16749         case ATTACH:
16750         case CAST:
16751         case TREAT:
16752         case TRIM:
16753         case LEFT:
16754         case RIGHT:
16755         case BOTH:
16756         case EMPTY:
16757         case MULTISET:
16758         case SUBMULTISET:
16759         case LEADING:
16760         case TRAILING:
16761         case CHAR_CS:
16762         case NCHAR_CS:
16763         case DBTIMEZONE:
16764         case SESSIONTIMEZONE:
16765         case AUTHENTICATED:
16766         case LINK:
16767         case SHARED:
16768         case DIRECTORY:
16769         case USER:
16770         case IDENTIFIER:
16771         case UNSIGNED_NUMERIC_LITERAL:
16772         case CHARACTER_LITERAL:
16773         case STRING_LITERAL:
16774         case QUOTED_LITERAL:
16775           simpleNode = ConditionalOrExpression();
16776                                                       sb.append(simpleNode.getImage());
16777           break;
16778         case CC_IF:
16779           simpleNode = CompilationExpression();
16780                                                     sb.append(simpleNode.getImage());
16781           break;
16782         default:
16783           jj_la1[213] = jj_gen;
16784           jj_consume_token(-1);
16785           throw new ParseException();
16786         }
16787       }
16788    jjtree.closeNodeScope(jjtn000, true);
16789    jjtc000 = false;
16790  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16791     } catch (Throwable jjte000) {
16792           if (jjtc000) {
16793             jjtree.clearNodeScope(jjtn000);
16794             jjtc000 = false;
16795           } else {
16796             jjtree.popNode();
16797           }
16798           if (jjte000 instanceof RuntimeException) {
16799             {if (true) throw (RuntimeException)jjte000;}
16800           }
16801           if (jjte000 instanceof ParseException) {
16802             {if (true) throw (ParseException)jjte000;}
16803           }
16804           {if (true) throw (Error)jjte000;}
16805     } finally {
16806           if (jjtc000) {
16807             jjtree.closeNodeScope(jjtn000, true);
16808           }
16809     }
16810     throw new Error("Missing return statement in function");
16811   }
16812 
16813   final public ASTCompilationExpression CompilationExpression() throws ParseException {
16814  /*@bgen(jjtree) CompilationExpression */
16815   ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16816   boolean jjtc000 = true;
16817   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16818   StringBuilder sb = new StringBuilder() ;
16819     try {
16820       jj_consume_token(CC_IF);
16821                    sb.append(" "); sb.append(token.image) ;
16822       simpleNode = ConditionalOrExpression();
16823                                                    sb.append(" "); sb.append(simpleNode.getImage());
16824       jj_consume_token(CC_THEN);
16825                      sb.append(" "); sb.append(token.image);
16826       simpleNode = Expression();
16827                                      sb.append(" "); sb.append(simpleNode.getImage());
16828       label_49:
16829       while (true) {
16830         switch (jj_nt.kind) {
16831         case CC_ELSIF:
16832           ;
16833           break;
16834         default:
16835           jj_la1[214] = jj_gen;
16836           break label_49;
16837         }
16838         jj_consume_token(CC_ELSIF);
16839                         sb.append(" "); sb.append(token.image);
16840         simpleNode = ConditionalOrExpression();
16841                                                     sb.append(" "); sb.append(simpleNode.getImage());
16842         jj_consume_token(CC_THEN);
16843                        sb.append(" "); sb.append(token.image);
16844         simpleNode = Expression();
16845                                        sb.append(" "); sb.append(simpleNode.getImage());
16846       }
16847       label_50:
16848       while (true) {
16849         switch (jj_nt.kind) {
16850         case CC_ELSE:
16851           ;
16852           break;
16853         default:
16854           jj_la1[215] = jj_gen;
16855           break label_50;
16856         }
16857         jj_consume_token(CC_ELSE);
16858                        sb.append(" "); sb.append(token.image);
16859         simpleNode = Expression();
16860                                         sb.append(" "); sb.append(simpleNode.getImage());
16861       }
16862       jj_consume_token(CC_END);
16863                     sb.append(" "); sb.append(token.image);
16864    jjtree.closeNodeScope(jjtn000, true);
16865    jjtc000 = false;
16866  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16867     } catch (Throwable jjte000) {
16868           if (jjtc000) {
16869             jjtree.clearNodeScope(jjtn000);
16870             jjtc000 = false;
16871           } else {
16872             jjtree.popNode();
16873           }
16874           if (jjte000 instanceof RuntimeException) {
16875             {if (true) throw (RuntimeException)jjte000;}
16876           }
16877           if (jjte000 instanceof ParseException) {
16878             {if (true) throw (ParseException)jjte000;}
16879           }
16880           {if (true) throw (Error)jjte000;}
16881     } finally {
16882           if (jjtc000) {
16883             jjtree.closeNodeScope(jjtn000, true);
16884           }
16885     }
16886     throw new Error("Missing return statement in function");
16887   }
16888 
16889   final public ASTAssignment Assignment() throws ParseException {
16890  /*@bgen(jjtree) Assignment */
16891   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16892   boolean jjtc000 = true;
16893   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16894     try {
16895       simpleNode = PrimaryExpression();
16896                                        sb.append(simpleNode.getImage());
16897       jj_consume_token(9);
16898       jj_consume_token(10);
16899                sb.append(" := ");
16900       simpleNode = Expression();
16901                                sb.append(simpleNode.getImage());
16902    jjtree.closeNodeScope(jjtn000, true);
16903    jjtc000 = false;
16904  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16905     } catch (Throwable jjte000) {
16906     if (jjtc000) {
16907       jjtree.clearNodeScope(jjtn000);
16908       jjtc000 = false;
16909     } else {
16910       jjtree.popNode();
16911     }
16912     if (jjte000 instanceof RuntimeException) {
16913       {if (true) throw (RuntimeException)jjte000;}
16914     }
16915     if (jjte000 instanceof ParseException) {
16916       {if (true) throw (ParseException)jjte000;}
16917     }
16918     {if (true) throw (Error)jjte000;}
16919     } finally {
16920     if (jjtc000) {
16921       jjtree.closeNodeScope(jjtn000, true);
16922     }
16923     }
16924     throw new Error("Missing return statement in function");
16925   }
16926 
16927   final public ASTCaseExpression CaseExpression() throws ParseException {
16928  /*@bgen(jjtree) CaseExpression */
16929   ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16930   boolean jjtc000 = true;
16931   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16932     try {
16933       thisToken = jj_consume_token(CASE);
16934                              sb.append(thisToken.image);
16935       switch (jj_nt.kind) {
16936       case 5:
16937       case 16:
16938       case 17:
16939       case REPLACE:
16940       case DEFINER:
16941       case CURRENT_USER:
16942       case LANGUAGE:
16943       case INLINE:
16944       case ADD:
16945       case AGGREGATE:
16946       case ARRAY:
16947       case AT:
16948       case ATTRIBUTE:
16949       case AUTHID:
16950       case BODY:
16951       case BULK:
16952       case BYTE:
16953       case CASCADE:
16954       case CASE:
16955       case CLOSE:
16956       case COALESCE:
16957       case COLLECT:
16958       case COLUMN:
16959       case COMMENT:
16960       case COMMIT:
16961       case CONSTRUCTOR:
16962       case CONTINUE:
16963       case CONVERT:
16964       case CURRENT:
16965       case CURSOR:
16966       case DATA:
16967       case DATE:
16968       case DAY:
16969       case DISABLE:
16970       case EDITIONABLE:
16971       case ELEMENT:
16972       case ENABLE:
16973       case ESCAPE:
16974       case EXCEPT:
16975       case EXCEPTIONS:
16976       case EXIT:
16977       case EXTERNAL:
16978       case EXTENDS:
16979       case EXTRACT:
16980       case FALSE:
16981       case FINAL:
16982       case FORCE:
16983       case FUNCTION:
16984       case GLOBAL:
16985       case HASH:
16986       case HEAP:
16987       case HOUR:
16988       case IMMEDIATE:
16989       case INDICES:
16990       case INDEXTYPE:
16991       case INDICATOR:
16992       case INSTANTIABLE:
16993       case INTERVAL:
16994       case INVALIDATE:
16995       case ISOLATION:
16996       case JAVA:
16997       case LEVEL:
16998       case LIMIT:
16999       case LOOP:
17000       case MAP:
17001       case MAX:
17002       case MEMBER:
17003       case MERGE:
17004       case MIN:
17005       case MINUTE:
17006       case MLSLABEL:
17007       case MODIFY:
17008       case MOD:
17009       case MONTH:
17010       case NATURAL:
17011       case NEW:
17012       case NEW_DOT:
17013       case NO:
17014       case NONEDITIONABLE:
17015       case NOT:
17016       case NULL:
17017       case NULLIF:
17018       case OBJECT:
17019       case OID:
17020       case OPAQUE:
17021       case OPEN:
17022       case OPERATOR:
17023       case ORGANIZATION:
17024       case OTHERS:
17025       case OVERRIDING:
17026       case PACKAGE:
17027       case PARTITION:
17028       case PRESERVE:
17029       case PRIVATE:
17030       case PROCEDURE:
17031       case RANGE:
17032       case RAW:
17033       case REAL:
17034       case RECORD:
17035       case REF:
17036       case RELEASE:
17037       case RELIES_ON:
17038       case RENAME:
17039       case RESULT:
17040       case RETURN:
17041       case RETURNING:
17042       case REVERSE:
17043       case ROLLBACK:
17044       case ROW:
17045       case ROWS:
17046       case ROWID:
17047       case ROWNUM:
17048       case SAVE:
17049       case SAVEPOINT:
17050       case SECOND:
17051       case SELECT:
17052       case SELF:
17053       case SET:
17054       case SPACE:
17055       case SQL:
17056       case SQLCODE:
17057       case SQLERRM:
17058       case STATIC:
17059       case SUBTYPE:
17060       case SUBSTITUTABLE:
17061       case SUCCESSFUL:
17062       case SYSDATE:
17063       case SYS_REFCURSOR:
17064       case TEMPORARY:
17065       case TIME:
17066       case TIMESTAMP:
17067       case TIMEZONE_REGION:
17068       case TIMEZONE_ABBR:
17069       case TIMEZONE_MINUTE:
17070       case TIMEZONE_HOUR:
17071       case TRANSACTION:
17072       case TRUE:
17073       case TYPE:
17074       case UNDER:
17075       case USING:
17076       case YES:
17077       case SHOW:
17078       case A:
17079       case DOUBLE:
17080       case DEC:
17081       case PRECISION:
17082       case INT:
17083       case NUMERIC:
17084       case NCHAR:
17085       case NVARCHAR2:
17086       case STRING:
17087       case UROWID:
17088       case VARRAY:
17089       case VARYING:
17090       case BFILE:
17091       case BLOB:
17092       case CLOB:
17093       case NCLOB:
17094       case YEAR:
17095       case LOCAL:
17096       case WITH:
17097       case ZONE:
17098       case CHARACTER:
17099       case AFTER:
17100       case BEFORE:
17101       case OLD:
17102       case PARENT:
17103       case CC_IF:
17104       case ANALYZE:
17105       case ASSOCIATE:
17106       case AUDIT:
17107       case COMPOUND:
17108       case DATABASE:
17109       case CALL:
17110       case DDL:
17111       case DISASSOCIATE:
17112       case EACH:
17113       case FOLLOWS:
17114       case LOGOFF:
17115       case LOGON:
17116       case NESTED:
17117       case NOAUDIT:
17118       case SCHEMA:
17119       case SERVERERROR:
17120       case SHUTDOWN:
17121       case STARTUP:
17122       case STATEMENT:
17123       case STATISTICS:
17124       case SUSPEND:
17125       case TRUNCATE:
17126       case WRAPPED:
17127       case LIBRARY:
17128       case NAME:
17129       case STRUCT:
17130       case CONTEXT:
17131       case PARAMETERS:
17132       case LENGTH:
17133       case TDO:
17134       case MAXLEN:
17135       case CHARSETID:
17136       case CHARSETFORM:
17137       case ACCEPT:
17138       case ACCESSIBLE:
17139       case COPY:
17140       case DEFINE:
17141       case DISCONNECT:
17142       case HOST:
17143       case PRINT:
17144       case QUIT:
17145       case REMARK:
17146       case UNDEFINE:
17147       case VARIABLE:
17148       case WHENEVER:
17149       case ATTACH:
17150       case CAST:
17151       case TREAT:
17152       case TRIM:
17153       case LEFT:
17154       case RIGHT:
17155       case BOTH:
17156       case EMPTY:
17157       case MULTISET:
17158       case SUBMULTISET:
17159       case LEADING:
17160       case TRAILING:
17161       case CHAR_CS:
17162       case NCHAR_CS:
17163       case DBTIMEZONE:
17164       case SESSIONTIMEZONE:
17165       case AUTHENTICATED:
17166       case LINK:
17167       case SHARED:
17168       case DIRECTORY:
17169       case USER:
17170       case IDENTIFIER:
17171       case UNSIGNED_NUMERIC_LITERAL:
17172       case CHARACTER_LITERAL:
17173       case STRING_LITERAL:
17174       case QUOTED_LITERAL:
17175         simpleNode = Expression();
17176                                       sb.append(" "); sb.append(simpleNode.getImage());
17177         break;
17178       default:
17179         jj_la1[216] = jj_gen;
17180         ;
17181       }
17182       label_51:
17183       while (true) {
17184         thisToken = jj_consume_token(WHEN);
17185                                  sb.append("  "); sb.append(thisToken.image);
17186         simpleNode = Expression();
17187                                             sb.append(" "); sb.append(simpleNode.getImage());
17188         thisToken = jj_consume_token(THEN);
17189                                    sb.append(" "); sb.append(thisToken.image);
17190         Expression();
17191                                  sb.append(" "); sb.append(simpleNode.getImage());
17192         switch (jj_nt.kind) {
17193         case WHEN:
17194           ;
17195           break;
17196         default:
17197           jj_la1[217] = jj_gen;
17198           break label_51;
17199         }
17200       }
17201       switch (jj_nt.kind) {
17202       case ELSE:
17203         thisToken = jj_consume_token(ELSE);
17204                                  sb.append(" "); sb.append(thisToken.image);
17205         Expression();
17206                                sb.append(" "); sb.append(simpleNode.getImage());
17207         break;
17208       default:
17209         jj_la1[218] = jj_gen;
17210         ;
17211       }
17212       thisToken = jj_consume_token(END);
17213                               sb.append(" "); sb.append(thisToken.image);
17214    jjtree.closeNodeScope(jjtn000, true);
17215    jjtc000 = false;
17216  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17217     } catch (Throwable jjte000) {
17218     if (jjtc000) {
17219       jjtree.clearNodeScope(jjtn000);
17220       jjtc000 = false;
17221     } else {
17222       jjtree.popNode();
17223     }
17224     if (jjte000 instanceof RuntimeException) {
17225       {if (true) throw (RuntimeException)jjte000;}
17226     }
17227     if (jjte000 instanceof ParseException) {
17228       {if (true) throw (ParseException)jjte000;}
17229     }
17230     {if (true) throw (Error)jjte000;}
17231     } finally {
17232     if (jjtc000) {
17233       jjtree.closeNodeScope(jjtn000, true);
17234     }
17235     }
17236     throw new Error("Missing return statement in function");
17237   }
17238 
17239 /*
17240 LIKE ( Expression ) [ <ESCAPE> <STRINGLITERAL>
17241 */
17242   final public ASTLikeExpression LikeExpression() throws ParseException {
17243  /*@bgen(jjtree) LikeExpression */
17244   ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17245   boolean jjtc000 = true;
17246   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17247     try {
17248       simpleNode = PrimaryExpression();
17249                                            sb.append(" "); sb.append(simpleNode.getImage());
17250       thisToken = jj_consume_token(LIKE);
17251                                 sb.append(thisToken.image);
17252       simpleNode = StringExpression();
17253                                             sb.append(" "); sb.append(simpleNode.getImage());
17254       switch (jj_nt.kind) {
17255       case ESCAPE:
17256         jj_consume_token(ESCAPE);
17257                    sb.append(" ESCAPE ");
17258         switch (jj_nt.kind) {
17259         case CHARACTER_LITERAL:
17260           jj_consume_token(CHARACTER_LITERAL);
17261                                 sb.append(" "); sb.append(token.toString());
17262           break;
17263         case STRING_LITERAL:
17264           simpleNode = StringLiteral();
17265                                            sb.append(" "); sb.append(simpleNode.getImage());
17266           break;
17267         default:
17268           jj_la1[219] = jj_gen;
17269           jj_consume_token(-1);
17270           throw new ParseException();
17271         }
17272         break;
17273       default:
17274         jj_la1[220] = jj_gen;
17275         ;
17276       }
17277       label_52:
17278       while (true) {
17279         switch (jj_nt.kind) {
17280         case 3:
17281           ;
17282           break;
17283         default:
17284           jj_la1[221] = jj_gen;
17285           break label_52;
17286         }
17287         jj_consume_token(3);
17288         simpleNode = Expression();
17289                                     sb.append("."); sb.append(simpleNode.getImage());
17290       }
17291    jjtree.closeNodeScope(jjtn000, true);
17292    jjtc000 = false;
17293  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17294     } catch (Throwable jjte000) {
17295     if (jjtc000) {
17296       jjtree.clearNodeScope(jjtn000);
17297       jjtc000 = false;
17298     } else {
17299       jjtree.popNode();
17300     }
17301     if (jjte000 instanceof RuntimeException) {
17302       {if (true) throw (RuntimeException)jjte000;}
17303     }
17304     if (jjte000 instanceof ParseException) {
17305       {if (true) throw (ParseException)jjte000;}
17306     }
17307     {if (true) throw (Error)jjte000;}
17308     } finally {
17309     if (jjtc000) {
17310       jjtree.closeNodeScope(jjtn000, true);
17311     }
17312     }
17313     throw new Error("Missing return statement in function");
17314   }
17315 
17316   final public ASTTrimExpression TrimExpression() throws ParseException {
17317  /*@bgen(jjtree) TrimExpression */
17318   ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17319   boolean jjtc000 = true;
17320   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17321     try {
17322       thisToken = jj_consume_token(TRIM);
17323                                 sb.append(thisToken.image);
17324       jj_consume_token(5);
17325               sb.append("(");
17326       switch (jj_nt.kind) {
17327       case BOTH:
17328       case LEADING:
17329       case TRAILING:
17330         switch (jj_nt.kind) {
17331         case LEADING:
17332           jj_consume_token(LEADING);
17333           break;
17334         case TRAILING:
17335           jj_consume_token(TRAILING);
17336           break;
17337         case BOTH:
17338           jj_consume_token(BOTH);
17339           break;
17340         default:
17341           jj_la1[222] = jj_gen;
17342           jj_consume_token(-1);
17343           throw new ParseException();
17344         }
17345                                                 sb.append(" "); sb.append(token.toString());
17346         break;
17347       default:
17348         jj_la1[223] = jj_gen;
17349         ;
17350       }
17351       switch (jj_nt.kind) {
17352       case 5:
17353       case REPLACE:
17354       case DEFINER:
17355       case CURRENT_USER:
17356       case LANGUAGE:
17357       case INLINE:
17358       case ADD:
17359       case AGGREGATE:
17360       case ARRAY:
17361       case AT:
17362       case ATTRIBUTE:
17363       case AUTHID:
17364       case BODY:
17365       case BULK:
17366       case BYTE:
17367       case CASCADE:
17368       case CASE:
17369       case CLOSE:
17370       case COALESCE:
17371       case COLLECT:
17372       case COLUMN:
17373       case COMMENT:
17374       case COMMIT:
17375       case CONSTRUCTOR:
17376       case CONTINUE:
17377       case CONVERT:
17378       case CURRENT:
17379       case CURSOR:
17380       case DATA:
17381       case DATE:
17382       case DAY:
17383       case DISABLE:
17384       case EDITIONABLE:
17385       case ELEMENT:
17386       case ENABLE:
17387       case ESCAPE:
17388       case EXCEPT:
17389       case EXCEPTIONS:
17390       case EXIT:
17391       case EXTERNAL:
17392       case EXTENDS:
17393       case EXTRACT:
17394       case FALSE:
17395       case FINAL:
17396       case FORCE:
17397       case FUNCTION:
17398       case GLOBAL:
17399       case HASH:
17400       case HEAP:
17401       case HOUR:
17402       case IMMEDIATE:
17403       case INDICES:
17404       case INDEXTYPE:
17405       case INDICATOR:
17406       case INSTANTIABLE:
17407       case INTERVAL:
17408       case INVALIDATE:
17409       case ISOLATION:
17410       case JAVA:
17411       case LEVEL:
17412       case LIMIT:
17413       case LOOP:
17414       case MAP:
17415       case MAX:
17416       case MEMBER:
17417       case MERGE:
17418       case MIN:
17419       case MINUTE:
17420       case MLSLABEL:
17421       case MODIFY:
17422       case MOD:
17423       case MONTH:
17424       case NATURAL:
17425       case NEW:
17426       case NEW_DOT:
17427       case NO:
17428       case NONEDITIONABLE:
17429       case NULL:
17430       case NULLIF:
17431       case OBJECT:
17432       case OID:
17433       case OPAQUE:
17434       case OPEN:
17435       case OPERATOR:
17436       case ORGANIZATION:
17437       case OTHERS:
17438       case OVERRIDING:
17439       case PACKAGE:
17440       case PARTITION:
17441       case PRESERVE:
17442       case PRIVATE:
17443       case PROCEDURE:
17444       case RANGE:
17445       case RAW:
17446       case REAL:
17447       case RECORD:
17448       case REF:
17449       case RELEASE:
17450       case RELIES_ON:
17451       case RENAME:
17452       case RESULT:
17453       case RETURN:
17454       case RETURNING:
17455       case REVERSE:
17456       case ROLLBACK:
17457       case ROW:
17458       case ROWS:
17459       case ROWID:
17460       case ROWNUM:
17461       case SAVE:
17462       case SAVEPOINT:
17463       case SECOND:
17464       case SELECT:
17465       case SELF:
17466       case SET:
17467       case SPACE:
17468       case SQL:
17469       case SQLCODE:
17470       case SQLERRM:
17471       case STATIC:
17472       case SUBTYPE:
17473       case SUBSTITUTABLE:
17474       case SUCCESSFUL:
17475       case SYSDATE:
17476       case SYS_REFCURSOR:
17477       case TEMPORARY:
17478       case TIME:
17479       case TIMESTAMP:
17480       case TIMEZONE_REGION:
17481       case TIMEZONE_ABBR:
17482       case TIMEZONE_MINUTE:
17483       case TIMEZONE_HOUR:
17484       case TRANSACTION:
17485       case TRUE:
17486       case TYPE:
17487       case UNDER:
17488       case USING:
17489       case YES:
17490       case SHOW:
17491       case A:
17492       case DOUBLE:
17493       case DEC:
17494       case PRECISION:
17495       case INT:
17496       case NUMERIC:
17497       case NCHAR:
17498       case NVARCHAR2:
17499       case STRING:
17500       case UROWID:
17501       case VARRAY:
17502       case VARYING:
17503       case BFILE:
17504       case BLOB:
17505       case CLOB:
17506       case NCLOB:
17507       case YEAR:
17508       case LOCAL:
17509       case WITH:
17510       case ZONE:
17511       case CHARACTER:
17512       case AFTER:
17513       case BEFORE:
17514       case OLD:
17515       case PARENT:
17516       case ANALYZE:
17517       case ASSOCIATE:
17518       case AUDIT:
17519       case COMPOUND:
17520       case DATABASE:
17521       case CALL:
17522       case DDL:
17523       case DISASSOCIATE:
17524       case EACH:
17525       case FOLLOWS:
17526       case LOGOFF:
17527       case LOGON:
17528       case NESTED:
17529       case NOAUDIT:
17530       case SCHEMA:
17531       case SERVERERROR:
17532       case SHUTDOWN:
17533       case STARTUP:
17534       case STATEMENT:
17535       case STATISTICS:
17536       case SUSPEND:
17537       case TRUNCATE:
17538       case WRAPPED:
17539       case LIBRARY:
17540       case NAME:
17541       case STRUCT:
17542       case CONTEXT:
17543       case PARAMETERS:
17544       case LENGTH:
17545       case TDO:
17546       case MAXLEN:
17547       case CHARSETID:
17548       case CHARSETFORM:
17549       case ACCEPT:
17550       case ACCESSIBLE:
17551       case COPY:
17552       case DEFINE:
17553       case DISCONNECT:
17554       case HOST:
17555       case PRINT:
17556       case QUIT:
17557       case REMARK:
17558       case UNDEFINE:
17559       case VARIABLE:
17560       case WHENEVER:
17561       case ATTACH:
17562       case CAST:
17563       case TREAT:
17564       case TRIM:
17565       case LEFT:
17566       case RIGHT:
17567       case BOTH:
17568       case EMPTY:
17569       case MULTISET:
17570       case SUBMULTISET:
17571       case LEADING:
17572       case TRAILING:
17573       case CHAR_CS:
17574       case NCHAR_CS:
17575       case DBTIMEZONE:
17576       case SESSIONTIMEZONE:
17577       case AUTHENTICATED:
17578       case LINK:
17579       case SHARED:
17580       case DIRECTORY:
17581       case USER:
17582       case IDENTIFIER:
17583       case UNSIGNED_NUMERIC_LITERAL:
17584       case CHARACTER_LITERAL:
17585       case STRING_LITERAL:
17586       case QUOTED_LITERAL:
17587         simpleNode = StringExpression();
17588                                              sb.append(" "); sb.append(simpleNode.getImage());
17589         break;
17590       default:
17591         jj_la1[224] = jj_gen;
17592         ;
17593       }
17594       jj_consume_token(FROM);
17595                         sb.append(thisToken.image);
17596       simpleNode = StringExpression();
17597                                            sb.append(" "); sb.append(simpleNode.getImage());
17598       jj_consume_token(7);
17599               sb.append(")");
17600    jjtree.closeNodeScope(jjtn000, true);
17601    jjtc000 = false;
17602  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17603     } catch (Throwable jjte000) {
17604     if (jjtc000) {
17605       jjtree.clearNodeScope(jjtn000);
17606       jjtc000 = false;
17607     } else {
17608       jjtree.popNode();
17609     }
17610     if (jjte000 instanceof RuntimeException) {
17611       {if (true) throw (RuntimeException)jjte000;}
17612     }
17613     if (jjte000 instanceof ParseException) {
17614       {if (true) throw (ParseException)jjte000;}
17615     }
17616     {if (true) throw (Error)jjte000;}
17617     } finally {
17618     if (jjtc000) {
17619       jjtree.closeNodeScope(jjtn000, true);
17620     }
17621     }
17622     throw new Error("Missing return statement in function");
17623   }
17624 
17625 /*
17626 TREAT ( Expression AS datatype)
17627 CAST ( Expression AS datatype)
17628 */
17629   final public ASTObjectExpression ObjectExpression() throws ParseException {
17630  /*@bgen(jjtree) ObjectExpression */
17631   ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17632   boolean jjtc000 = true;
17633   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17634     try {
17635       switch (jj_nt.kind) {
17636       case CAST:
17637         thisToken = jj_consume_token(CAST);
17638         break;
17639       case TREAT:
17640         thisToken = jj_consume_token(TREAT);
17641         break;
17642       default:
17643         jj_la1[225] = jj_gen;
17644         jj_consume_token(-1);
17645         throw new ParseException();
17646       }
17647                                                       sb.append(thisToken.image);
17648       jj_consume_token(5);
17649               sb.append("(");
17650       simpleNode = Expression();
17651                                       sb.append(" "); sb.append(simpleNode.getImage());
17652       switch (jj_nt.kind) {
17653       case AT:
17654         jj_consume_token(AT);
17655         jj_consume_token(TIME);
17656         jj_consume_token(ZONE);
17657         simpleNode = PrimaryExpression();
17658                                                                sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17659         break;
17660       default:
17661         jj_la1[226] = jj_gen;
17662         ;
17663       }
17664       jj_consume_token(AS);
17665                sb.append(" AS ");
17666       simpleNode = Datatype();
17667                                     sb.append(" "); sb.append(simpleNode.getImage());
17668       jj_consume_token(7);
17669               sb.append(")");
17670       label_53:
17671       while (true) {
17672         switch (jj_nt.kind) {
17673         case 3:
17674           ;
17675           break;
17676         default:
17677           jj_la1[227] = jj_gen;
17678           break label_53;
17679         }
17680         jj_consume_token(3);
17681         Expression();
17682       }
17683    jjtree.closeNodeScope(jjtn000, true);
17684    jjtc000 = false;
17685  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17686     } catch (Throwable jjte000) {
17687     if (jjtc000) {
17688       jjtree.clearNodeScope(jjtn000);
17689       jjtc000 = false;
17690     } else {
17691       jjtree.popNode();
17692     }
17693     if (jjte000 instanceof RuntimeException) {
17694       {if (true) throw (RuntimeException)jjte000;}
17695     }
17696     if (jjte000 instanceof ParseException) {
17697       {if (true) throw (ParseException)jjte000;}
17698     }
17699     {if (true) throw (Error)jjte000;}
17700     } finally {
17701     if (jjtc000) {
17702       jjtree.closeNodeScope(jjtn000, true);
17703     }
17704     }
17705     throw new Error("Missing return statement in function");
17706   }
17707 
17708   final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17709  /*@bgen(jjtree) ConditionalOrExpression */
17710   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17711   boolean jjtc000 = true;
17712   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17713     try {
17714       simpleNode = ConditionalAndExpression();
17715                                                sb.append(simpleNode.getImage());
17716       label_54:
17717       while (true) {
17718         switch (jj_nt.kind) {
17719         case OR:
17720           ;
17721           break;
17722         default:
17723           jj_la1[228] = jj_gen;
17724           break label_54;
17725         }
17726         jj_consume_token(OR);
17727             sb.append(" OR ");
17728         simpleNode = ConditionalAndExpression();
17729                                                 sb.append(simpleNode.getImage());
17730       }
17731    jjtree.closeNodeScope(jjtn000, true);
17732    jjtc000 = false;
17733  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17734     } catch (Throwable jjte000) {
17735     if (jjtc000) {
17736       jjtree.clearNodeScope(jjtn000);
17737       jjtc000 = false;
17738     } else {
17739       jjtree.popNode();
17740     }
17741     if (jjte000 instanceof RuntimeException) {
17742       {if (true) throw (RuntimeException)jjte000;}
17743     }
17744     if (jjte000 instanceof ParseException) {
17745       {if (true) throw (ParseException)jjte000;}
17746     }
17747     {if (true) throw (Error)jjte000;}
17748     } finally {
17749     if (jjtc000) {
17750       jjtree.closeNodeScope(jjtn000, true);
17751     }
17752     }
17753     throw new Error("Missing return statement in function");
17754   }
17755 
17756   final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17757  /*@bgen(jjtree) ConditionalAndExpression */
17758   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17759   boolean jjtc000 = true;
17760   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17761     try {
17762       simpleNode = EqualityExpression();
17763                                           sb.append(simpleNode.getImage());
17764       label_55:
17765       while (true) {
17766         switch (jj_nt.kind) {
17767         case AND:
17768           ;
17769           break;
17770         default:
17771           jj_la1[229] = jj_gen;
17772           break label_55;
17773         }
17774         jj_consume_token(AND);
17775                sb.append(" AND ");
17776         simpleNode = EqualityExpression();
17777                                             sb.append(simpleNode.getImage());
17778       }
17779    jjtree.closeNodeScope(jjtn000, true);
17780    jjtc000 = false;
17781  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17782     } catch (Throwable jjte000) {
17783     if (jjtc000) {
17784       jjtree.clearNodeScope(jjtn000);
17785       jjtc000 = false;
17786     } else {
17787       jjtree.popNode();
17788     }
17789     if (jjte000 instanceof RuntimeException) {
17790       {if (true) throw (RuntimeException)jjte000;}
17791     }
17792     if (jjte000 instanceof ParseException) {
17793       {if (true) throw (ParseException)jjte000;}
17794     }
17795     {if (true) throw (Error)jjte000;}
17796     } finally {
17797     if (jjtc000) {
17798       jjtree.closeNodeScope(jjtn000, true);
17799     }
17800     }
17801     throw new Error("Missing return statement in function");
17802   }
17803 
17804   final public ASTEqualityExpression EqualityExpression() throws ParseException {
17805  /*@bgen(jjtree) EqualityExpression */
17806   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17807   boolean jjtc000 = true;
17808   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17809     try {
17810       simpleNode = RelationalExpression();
17811              sb.append(simpleNode.getImage());
17812       label_56:
17813       while (true) {
17814         switch (jj_nt.kind) {
17815         case 10:
17816         case 13:
17817         case IS:
17818           ;
17819           break;
17820         default:
17821           jj_la1[230] = jj_gen;
17822           break label_56;
17823         }
17824         switch (jj_nt.kind) {
17825         case 10:
17826           jj_consume_token(10);
17827                      sb.append(" = ");
17828           break;
17829         case 13:
17830           jj_consume_token(13);
17831           jj_consume_token(10);
17832                          sb.append(" != ");
17833           break;
17834         case IS:
17835           jj_consume_token(IS);
17836                      sb.append(" IS ");
17837           break;
17838         default:
17839           jj_la1[231] = jj_gen;
17840           jj_consume_token(-1);
17841           throw new ParseException();
17842         }
17843         simpleNode = RelationalExpression();
17844               sb.append(simpleNode.getImage());
17845       }
17846    jjtree.closeNodeScope(jjtn000, true);
17847    jjtc000 = false;
17848  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17849     } catch (Throwable jjte000) {
17850     if (jjtc000) {
17851       jjtree.clearNodeScope(jjtn000);
17852       jjtc000 = false;
17853     } else {
17854       jjtree.popNode();
17855     }
17856     if (jjte000 instanceof RuntimeException) {
17857       {if (true) throw (RuntimeException)jjte000;}
17858     }
17859     if (jjte000 instanceof ParseException) {
17860       {if (true) throw (ParseException)jjte000;}
17861     }
17862     {if (true) throw (Error)jjte000;}
17863     } finally {
17864     if (jjtc000) {
17865       jjtree.closeNodeScope(jjtn000, true);
17866     }
17867     }
17868     throw new Error("Missing return statement in function");
17869   }
17870 
17871 /**
17872  * 2006-05-23 - Matthias Hendler - added FROM
17873  */
17874   final public ASTRelationalExpression RelationalExpression() throws ParseException {
17875  /*@bgen(jjtree) RelationalExpression */
17876   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17877   boolean jjtc000 = true;
17878   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17879     try {
17880       simpleNode = AdditiveExpression();
17881                                          sb.append(simpleNode.getImage());
17882       label_57:
17883       while (true) {
17884         switch (jj_nt.kind) {
17885         case 14:
17886         case 15:
17887         case BETWEEN:
17888         case FROM:
17889         case IN:
17890         case LIKE:
17891         case MEMBER:
17892         case NOT:
17893         case MULTISET:
17894         case SUBMULTISET:
17895           ;
17896           break;
17897         default:
17898           jj_la1[232] = jj_gen;
17899           break label_57;
17900         }
17901         switch (jj_nt.kind) {
17902         case 14:
17903         case 15:
17904           switch (jj_nt.kind) {
17905           case 14:
17906             jj_consume_token(14);
17907                       sb.append("<");
17908             switch (jj_nt.kind) {
17909             case 15:
17910               jj_consume_token(15);
17911                      sb.append(">");
17912               break;
17913             default:
17914               jj_la1[233] = jj_gen;
17915               ;
17916             }
17917             break;
17918           case 15:
17919             jj_consume_token(15);
17920                      sb.append(">");
17921             break;
17922           default:
17923             jj_la1[234] = jj_gen;
17924             jj_consume_token(-1);
17925             throw new ParseException();
17926           }
17927           switch (jj_nt.kind) {
17928           case 10:
17929             jj_consume_token(10);
17930                    sb.append("=");
17931             break;
17932           default:
17933             jj_la1[235] = jj_gen;
17934             ;
17935           }
17936         sb.append(" ");
17937           break;
17938         case BETWEEN:
17939         case FROM:
17940         case IN:
17941         case LIKE:
17942         case MEMBER:
17943         case NOT:
17944         case SUBMULTISET:
17945           switch (jj_nt.kind) {
17946           case NOT:
17947             jj_consume_token(NOT);
17948                 sb.append(" NOT ");
17949             break;
17950           default:
17951             jj_la1[236] = jj_gen;
17952             ;
17953           }
17954           switch (jj_nt.kind) {
17955           case IN:
17956             jj_consume_token(IN);
17957                sb.append(" IN ");
17958             break;
17959           case BETWEEN:
17960             jj_consume_token(BETWEEN);
17961                       sb.append(" BETWEEN ");
17962             break;
17963           case LIKE:
17964             jj_consume_token(LIKE);
17965                    sb.append(" LIKE ");
17966             break;
17967           case FROM:
17968             jj_consume_token(FROM);
17969                   sb.append(" FROM ");
17970             break;
17971           case MEMBER:
17972           case SUBMULTISET:
17973             switch (jj_nt.kind) {
17974             case MEMBER:
17975               jj_consume_token(MEMBER);
17976                         sb.append(" MEMBER ");
17977               break;
17978             case SUBMULTISET:
17979               jj_consume_token(SUBMULTISET);
17980                              sb.append(" SUBMULTISET ");
17981               break;
17982             default:
17983               jj_la1[237] = jj_gen;
17984               jj_consume_token(-1);
17985               throw new ParseException();
17986             }
17987             switch (jj_nt.kind) {
17988             case OF:
17989               jj_consume_token(OF);
17990                   sb.append(" OF ");
17991               break;
17992             default:
17993               jj_la1[238] = jj_gen;
17994               ;
17995             }
17996             break;
17997           default:
17998             jj_la1[239] = jj_gen;
17999             jj_consume_token(-1);
18000             throw new ParseException();
18001           }
18002           break;
18003         case MULTISET:
18004           jj_consume_token(MULTISET);
18005                     sb.append (" MULTISET " );
18006           switch (jj_nt.kind) {
18007           case EXCEPT:
18008             jj_consume_token(EXCEPT);
18009                        sb.append (" EXCEPT " );
18010             break;
18011           case INTERSECT:
18012             jj_consume_token(INTERSECT);
18013                           sb.append (" INTERSECT " );
18014             break;
18015           case UNION:
18016             jj_consume_token(UNION);
18017                       sb.append (" UNION " );
18018             break;
18019           default:
18020             jj_la1[240] = jj_gen;
18021             jj_consume_token(-1);
18022             throw new ParseException();
18023           }
18024           switch (jj_nt.kind) {
18025           case ALL:
18026           case DISTINCT:
18027             switch (jj_nt.kind) {
18028             case DISTINCT:
18029               jj_consume_token(DISTINCT);
18030                          sb.append (" DISTINCT " );
18031               break;
18032             case ALL:
18033               jj_consume_token(ALL);
18034                     sb.append (" ALL " );
18035               break;
18036             default:
18037               jj_la1[241] = jj_gen;
18038               jj_consume_token(-1);
18039               throw new ParseException();
18040             }
18041             break;
18042           default:
18043             jj_la1[242] = jj_gen;
18044             ;
18045           }
18046           break;
18047         default:
18048           jj_la1[243] = jj_gen;
18049           jj_consume_token(-1);
18050           throw new ParseException();
18051         }
18052         AdditiveExpression();
18053                              sb.append(simpleNode.getImage());
18054         switch (jj_nt.kind) {
18055         case ESCAPE:
18056           jj_consume_token(ESCAPE);
18057                    sb.append(" ESCAPE ");
18058           switch (jj_nt.kind) {
18059           case CHARACTER_LITERAL:
18060             jj_consume_token(CHARACTER_LITERAL);
18061                                 sb.append(" "); sb.append(token.toString());
18062             break;
18063           case STRING_LITERAL:
18064             simpleNode = StringLiteral();
18065                                            sb.append(" "); sb.append(simpleNode.getImage());
18066             break;
18067           default:
18068             jj_la1[244] = jj_gen;
18069             jj_consume_token(-1);
18070             throw new ParseException();
18071           }
18072           break;
18073         default:
18074           jj_la1[245] = jj_gen;
18075           ;
18076         }
18077       }
18078    jjtree.closeNodeScope(jjtn000, true);
18079    jjtc000 = false;
18080  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18081     } catch (Throwable jjte000) {
18082    if (jjtc000) {
18083      jjtree.clearNodeScope(jjtn000);
18084      jjtc000 = false;
18085    } else {
18086      jjtree.popNode();
18087    }
18088    if (jjte000 instanceof RuntimeException) {
18089      {if (true) throw (RuntimeException)jjte000;}
18090    }
18091    if (jjte000 instanceof ParseException) {
18092      {if (true) throw (ParseException)jjte000;}
18093    }
18094    {if (true) throw (Error)jjte000;}
18095     } finally {
18096    if (jjtc000) {
18097      jjtree.closeNodeScope(jjtn000, true);
18098    }
18099     }
18100     throw new Error("Missing return statement in function");
18101   }
18102 
18103   final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18104  /*@bgen(jjtree) AdditiveExpression */
18105   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18106   boolean jjtc000 = true;
18107   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18108     try {
18109       simpleNode = MultiplicativeExpression();
18110                                                sb.append(simpleNode.getImage());
18111       label_58:
18112       while (true) {
18113         switch (jj_nt.kind) {
18114         case 16:
18115         case 17:
18116         case 18:
18117           ;
18118           break;
18119         default:
18120           jj_la1[246] = jj_gen;
18121           break label_58;
18122         }
18123         switch (jj_nt.kind) {
18124         case 16:
18125           jj_consume_token(16);
18126                sb.append(" + ");
18127           break;
18128         case 17:
18129           jj_consume_token(17);
18130                sb.append(" - ");
18131           break;
18132         case 18:
18133           jj_consume_token(18);
18134                 sb.append(" || ");
18135           break;
18136         default:
18137           jj_la1[247] = jj_gen;
18138           jj_consume_token(-1);
18139           throw new ParseException();
18140         }
18141         simpleNode = MultiplicativeExpression();
18142                                                  sb.append(simpleNode.getImage());
18143       }
18144    jjtree.closeNodeScope(jjtn000, true);
18145    jjtc000 = false;
18146  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18147     } catch (Throwable jjte000) {
18148    if (jjtc000) {
18149      jjtree.clearNodeScope(jjtn000);
18150      jjtc000 = false;
18151    } else {
18152      jjtree.popNode();
18153    }
18154    if (jjte000 instanceof RuntimeException) {
18155      {if (true) throw (RuntimeException)jjte000;}
18156    }
18157    if (jjte000 instanceof ParseException) {
18158      {if (true) throw (ParseException)jjte000;}
18159    }
18160    {if (true) throw (Error)jjte000;}
18161     } finally {
18162    if (jjtc000) {
18163      jjtree.closeNodeScope(jjtn000, true);
18164    }
18165     }
18166     throw new Error("Missing return statement in function");
18167   }
18168 
18169   final public ASTStringExpression StringExpression() throws ParseException {
18170  /*@bgen(jjtree) StringExpression */
18171   ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18172   boolean jjtc000 = true;
18173   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18174     try {
18175       simpleNode = PrimaryExpression();
18176                                         sb.append(simpleNode.getImage());
18177       label_59:
18178       while (true) {
18179         switch (jj_nt.kind) {
18180         case 18:
18181           ;
18182           break;
18183         default:
18184           jj_la1[248] = jj_gen;
18185           break label_59;
18186         }
18187         jj_consume_token(18);
18188                sb.append(" || ");
18189         simpleNode = PrimaryExpression();
18190                                           sb.append(simpleNode.getImage());
18191       }
18192    jjtree.closeNodeScope(jjtn000, true);
18193    jjtc000 = false;
18194  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18195     } catch (Throwable jjte000) {
18196    if (jjtc000) {
18197      jjtree.clearNodeScope(jjtn000);
18198      jjtc000 = false;
18199    } else {
18200      jjtree.popNode();
18201    }
18202    if (jjte000 instanceof RuntimeException) {
18203      {if (true) throw (RuntimeException)jjte000;}
18204    }
18205    if (jjte000 instanceof ParseException) {
18206      {if (true) throw (ParseException)jjte000;}
18207    }
18208    {if (true) throw (Error)jjte000;}
18209     } finally {
18210    if (jjtc000) {
18211      jjtree.closeNodeScope(jjtn000, true);
18212    }
18213     }
18214     throw new Error("Missing return statement in function");
18215   }
18216 
18217   final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18218  /*@bgen(jjtree) MultiplicativeExpression */
18219   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18220   boolean jjtc000 = true;
18221   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18222     try {
18223       simpleNode = UnaryExpression(true);
18224                                           sb.append(simpleNode.getImage());
18225       label_60:
18226       while (true) {
18227         switch (jj_nt.kind) {
18228         case 1:
18229         case 19:
18230         case 20:
18231         case MOD:
18232           ;
18233           break;
18234         default:
18235           jj_la1[249] = jj_gen;
18236           break label_60;
18237         }
18238         switch (jj_nt.kind) {
18239         case 19:
18240           jj_consume_token(19);
18241                  sb.append(" ** ");
18242           break;
18243         case 20:
18244           jj_consume_token(20);
18245                 sb.append(" * ");
18246           break;
18247         case 1:
18248           jj_consume_token(1);
18249                 sb.append(" / ");
18250           break;
18251         case MOD:
18252           jj_consume_token(MOD);
18253                   sb.append(" MOD ");
18254           break;
18255         default:
18256           jj_la1[250] = jj_gen;
18257           jj_consume_token(-1);
18258           throw new ParseException();
18259         }
18260         simpleNode = UnaryExpression(true);
18261                                             sb.append(simpleNode.getImage());
18262       }
18263    jjtree.closeNodeScope(jjtn000, true);
18264    jjtc000 = false;
18265  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18266     } catch (Throwable jjte000) {
18267    if (jjtc000) {
18268      jjtree.clearNodeScope(jjtn000);
18269      jjtc000 = false;
18270    } else {
18271      jjtree.popNode();
18272    }
18273    if (jjte000 instanceof RuntimeException) {
18274      {if (true) throw (RuntimeException)jjte000;}
18275    }
18276    if (jjte000 instanceof ParseException) {
18277      {if (true) throw (ParseException)jjte000;}
18278    }
18279    {if (true) throw (Error)jjte000;}
18280     } finally {
18281    if (jjtc000) {
18282      jjtree.closeNodeScope(jjtn000, true);
18283    }
18284     }
18285     throw new Error("Missing return statement in function");
18286   }
18287 
18288   final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18289  /*@bgen(jjtree) UnaryExpression */
18290   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18291   boolean jjtc000 = true;
18292   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18293     try {
18294       switch (jj_nt.kind) {
18295       case 16:
18296       case 17:
18297         switch (jj_nt.kind) {
18298         case 16:
18299           jj_consume_token(16);
18300               sb.append(isUnarySign ? " +" : " + ");
18301           break;
18302         case 17:
18303           jj_consume_token(17);
18304               sb.append(isUnarySign ? " -" : " - ");
18305           break;
18306         default:
18307           jj_la1[251] = jj_gen;
18308           jj_consume_token(-1);
18309           throw new ParseException();
18310         }
18311         simpleNode = UnaryExpression(false);
18312                                             sb.append(simpleNode.getImage());
18313         break;
18314       case 5:
18315       case REPLACE:
18316       case DEFINER:
18317       case CURRENT_USER:
18318       case LANGUAGE:
18319       case INLINE:
18320       case ADD:
18321       case AGGREGATE:
18322       case ARRAY:
18323       case AT:
18324       case ATTRIBUTE:
18325       case AUTHID:
18326       case BODY:
18327       case BULK:
18328       case BYTE:
18329       case CASCADE:
18330       case CASE:
18331       case CLOSE:
18332       case COALESCE:
18333       case COLLECT:
18334       case COLUMN:
18335       case COMMENT:
18336       case COMMIT:
18337       case CONSTRUCTOR:
18338       case CONTINUE:
18339       case CONVERT:
18340       case CURRENT:
18341       case CURSOR:
18342       case DATA:
18343       case DATE:
18344       case DAY:
18345       case DISABLE:
18346       case EDITIONABLE:
18347       case ELEMENT:
18348       case ENABLE:
18349       case ESCAPE:
18350       case EXCEPT:
18351       case EXCEPTIONS:
18352       case EXIT:
18353       case EXTERNAL:
18354       case EXTENDS:
18355       case EXTRACT:
18356       case FALSE:
18357       case FINAL:
18358       case FORCE:
18359       case FUNCTION:
18360       case GLOBAL:
18361       case HASH:
18362       case HEAP:
18363       case HOUR:
18364       case IMMEDIATE:
18365       case INDICES:
18366       case INDEXTYPE:
18367       case INDICATOR:
18368       case INSTANTIABLE:
18369       case INTERVAL:
18370       case INVALIDATE:
18371       case ISOLATION:
18372       case JAVA:
18373       case LEVEL:
18374       case LIMIT:
18375       case LOOP:
18376       case MAP:
18377       case MAX:
18378       case MEMBER:
18379       case MERGE:
18380       case MIN:
18381       case MINUTE:
18382       case MLSLABEL:
18383       case MODIFY:
18384       case MOD:
18385       case MONTH:
18386       case NATURAL:
18387       case NEW:
18388       case NEW_DOT:
18389       case NO:
18390       case NONEDITIONABLE:
18391       case NOT:
18392       case NULL:
18393       case NULLIF:
18394       case OBJECT:
18395       case OID:
18396       case OPAQUE:
18397       case OPEN:
18398       case OPERATOR:
18399       case ORGANIZATION:
18400       case OTHERS:
18401       case OVERRIDING:
18402       case PACKAGE:
18403       case PARTITION:
18404       case PRESERVE:
18405       case PRIVATE:
18406       case PROCEDURE:
18407       case RANGE:
18408       case RAW:
18409       case REAL:
18410       case RECORD:
18411       case REF:
18412       case RELEASE:
18413       case RELIES_ON:
18414       case RENAME:
18415       case RESULT:
18416       case RETURN:
18417       case RETURNING:
18418       case REVERSE:
18419       case ROLLBACK:
18420       case ROW:
18421       case ROWS:
18422       case ROWID:
18423       case ROWNUM:
18424       case SAVE:
18425       case SAVEPOINT:
18426       case SECOND:
18427       case SELECT:
18428       case SELF:
18429       case SET:
18430       case SPACE:
18431       case SQL:
18432       case SQLCODE:
18433       case SQLERRM:
18434       case STATIC:
18435       case SUBTYPE:
18436       case SUBSTITUTABLE:
18437       case SUCCESSFUL:
18438       case SYSDATE:
18439       case SYS_REFCURSOR:
18440       case TEMPORARY:
18441       case TIME:
18442       case TIMESTAMP:
18443       case TIMEZONE_REGION:
18444       case TIMEZONE_ABBR:
18445       case TIMEZONE_MINUTE:
18446       case TIMEZONE_HOUR:
18447       case TRANSACTION:
18448       case TRUE:
18449       case TYPE:
18450       case UNDER:
18451       case USING:
18452       case YES:
18453       case SHOW:
18454       case A:
18455       case DOUBLE:
18456       case DEC:
18457       case PRECISION:
18458       case INT:
18459       case NUMERIC:
18460       case NCHAR:
18461       case NVARCHAR2:
18462       case STRING:
18463       case UROWID:
18464       case VARRAY:
18465       case VARYING:
18466       case BFILE:
18467       case BLOB:
18468       case CLOB:
18469       case NCLOB:
18470       case YEAR:
18471       case LOCAL:
18472       case WITH:
18473       case ZONE:
18474       case CHARACTER:
18475       case AFTER:
18476       case BEFORE:
18477       case OLD:
18478       case PARENT:
18479       case ANALYZE:
18480       case ASSOCIATE:
18481       case AUDIT:
18482       case COMPOUND:
18483       case DATABASE:
18484       case CALL:
18485       case DDL:
18486       case DISASSOCIATE:
18487       case EACH:
18488       case FOLLOWS:
18489       case LOGOFF:
18490       case LOGON:
18491       case NESTED:
18492       case NOAUDIT:
18493       case SCHEMA:
18494       case SERVERERROR:
18495       case SHUTDOWN:
18496       case STARTUP:
18497       case STATEMENT:
18498       case STATISTICS:
18499       case SUSPEND:
18500       case TRUNCATE:
18501       case WRAPPED:
18502       case LIBRARY:
18503       case NAME:
18504       case STRUCT:
18505       case CONTEXT:
18506       case PARAMETERS:
18507       case LENGTH:
18508       case TDO:
18509       case MAXLEN:
18510       case CHARSETID:
18511       case CHARSETFORM:
18512       case ACCEPT:
18513       case ACCESSIBLE:
18514       case COPY:
18515       case DEFINE:
18516       case DISCONNECT:
18517       case HOST:
18518       case PRINT:
18519       case QUIT:
18520       case REMARK:
18521       case UNDEFINE:
18522       case VARIABLE:
18523       case WHENEVER:
18524       case ATTACH:
18525       case CAST:
18526       case TREAT:
18527       case TRIM:
18528       case LEFT:
18529       case RIGHT:
18530       case BOTH:
18531       case EMPTY:
18532       case MULTISET:
18533       case SUBMULTISET:
18534       case LEADING:
18535       case TRAILING:
18536       case CHAR_CS:
18537       case NCHAR_CS:
18538       case DBTIMEZONE:
18539       case SESSIONTIMEZONE:
18540       case AUTHENTICATED:
18541       case LINK:
18542       case SHARED:
18543       case DIRECTORY:
18544       case USER:
18545       case IDENTIFIER:
18546       case UNSIGNED_NUMERIC_LITERAL:
18547       case CHARACTER_LITERAL:
18548       case STRING_LITERAL:
18549       case QUOTED_LITERAL:
18550         simpleNode = UnaryExpressionNotPlusMinus();
18551                                                    sb.append(simpleNode.getImage());
18552         break;
18553       default:
18554         jj_la1[252] = jj_gen;
18555         jj_consume_token(-1);
18556         throw new ParseException();
18557       }
18558    jjtree.closeNodeScope(jjtn000, true);
18559    jjtc000 = false;
18560  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18561     } catch (Throwable jjte000) {
18562    if (jjtc000) {
18563      jjtree.clearNodeScope(jjtn000);
18564      jjtc000 = false;
18565    } else {
18566      jjtree.popNode();
18567    }
18568    if (jjte000 instanceof RuntimeException) {
18569      {if (true) throw (RuntimeException)jjte000;}
18570    }
18571    if (jjte000 instanceof ParseException) {
18572      {if (true) throw (ParseException)jjte000;}
18573    }
18574    {if (true) throw (Error)jjte000;}
18575     } finally {
18576    if (jjtc000) {
18577      jjtree.closeNodeScope(jjtn000, true);
18578    }
18579     }
18580     throw new Error("Missing return statement in function");
18581   }
18582 
18583   final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18584  /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
18585   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18586   boolean jjtc000 = true;
18587   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18588     try {
18589       switch (jj_nt.kind) {
18590       case NOT:
18591         jj_consume_token(NOT);
18592            sb.append(" NOT ");
18593         simpleNode = UnaryExpression(false);
18594                                            sb.append(simpleNode.getImage());
18595         break;
18596       case 5:
18597       case REPLACE:
18598       case DEFINER:
18599       case CURRENT_USER:
18600       case LANGUAGE:
18601       case INLINE:
18602       case ADD:
18603       case AGGREGATE:
18604       case ARRAY:
18605       case AT:
18606       case ATTRIBUTE:
18607       case AUTHID:
18608       case BODY:
18609       case BULK:
18610       case BYTE:
18611       case CASCADE:
18612       case CASE:
18613       case CLOSE:
18614       case COALESCE:
18615       case COLLECT:
18616       case COLUMN:
18617       case COMMENT:
18618       case COMMIT:
18619       case CONSTRUCTOR:
18620       case CONTINUE:
18621       case CONVERT:
18622       case CURRENT:
18623       case CURSOR:
18624       case DATA:
18625       case DATE:
18626       case DAY:
18627       case DISABLE:
18628       case EDITIONABLE:
18629       case ELEMENT:
18630       case ENABLE:
18631       case ESCAPE:
18632       case EXCEPT:
18633       case EXCEPTIONS:
18634       case EXIT:
18635       case EXTERNAL:
18636       case EXTENDS:
18637       case EXTRACT:
18638       case FALSE:
18639       case FINAL:
18640       case FORCE:
18641       case FUNCTION:
18642       case GLOBAL:
18643       case HASH:
18644       case HEAP:
18645       case HOUR:
18646       case IMMEDIATE:
18647       case INDICES:
18648       case INDEXTYPE:
18649       case INDICATOR:
18650       case INSTANTIABLE:
18651       case INTERVAL:
18652       case INVALIDATE:
18653       case ISOLATION:
18654       case JAVA:
18655       case LEVEL:
18656       case LIMIT:
18657       case LOOP:
18658       case MAP:
18659       case MAX:
18660       case MEMBER:
18661       case MERGE:
18662       case MIN:
18663       case MINUTE:
18664       case MLSLABEL:
18665       case MODIFY:
18666       case MOD:
18667       case MONTH:
18668       case NATURAL:
18669       case NEW:
18670       case NEW_DOT:
18671       case NO:
18672       case NONEDITIONABLE:
18673       case NULL:
18674       case NULLIF:
18675       case OBJECT:
18676       case OID:
18677       case OPAQUE:
18678       case OPEN:
18679       case OPERATOR:
18680       case ORGANIZATION:
18681       case OTHERS:
18682       case OVERRIDING:
18683       case PACKAGE:
18684       case PARTITION:
18685       case PRESERVE:
18686       case PRIVATE:
18687       case PROCEDURE:
18688       case RANGE:
18689       case RAW:
18690       case REAL:
18691       case RECORD:
18692       case REF:
18693       case RELEASE:
18694       case RELIES_ON:
18695       case RENAME:
18696       case RESULT:
18697       case RETURN:
18698       case RETURNING:
18699       case REVERSE:
18700       case ROLLBACK:
18701       case ROW:
18702       case ROWS:
18703       case ROWID:
18704       case ROWNUM:
18705       case SAVE:
18706       case SAVEPOINT:
18707       case SECOND:
18708       case SELECT:
18709       case SELF:
18710       case SET:
18711       case SPACE:
18712       case SQL:
18713       case SQLCODE:
18714       case SQLERRM:
18715       case STATIC:
18716       case SUBTYPE:
18717       case SUBSTITUTABLE:
18718       case SUCCESSFUL:
18719       case SYSDATE:
18720       case SYS_REFCURSOR:
18721       case TEMPORARY:
18722       case TIME:
18723       case TIMESTAMP:
18724       case TIMEZONE_REGION:
18725       case TIMEZONE_ABBR:
18726       case TIMEZONE_MINUTE:
18727       case TIMEZONE_HOUR:
18728       case TRANSACTION:
18729       case TRUE:
18730       case TYPE:
18731       case UNDER:
18732       case USING:
18733       case YES:
18734       case SHOW:
18735       case A:
18736       case DOUBLE:
18737       case DEC:
18738       case PRECISION:
18739       case INT:
18740       case NUMERIC:
18741       case NCHAR:
18742       case NVARCHAR2:
18743       case STRING:
18744       case UROWID:
18745       case VARRAY:
18746       case VARYING:
18747       case BFILE:
18748       case BLOB:
18749       case CLOB:
18750       case NCLOB:
18751       case YEAR:
18752       case LOCAL:
18753       case WITH:
18754       case ZONE:
18755       case CHARACTER:
18756       case AFTER:
18757       case BEFORE:
18758       case OLD:
18759       case PARENT:
18760       case ANALYZE:
18761       case ASSOCIATE:
18762       case AUDIT:
18763       case COMPOUND:
18764       case DATABASE:
18765       case CALL:
18766       case DDL:
18767       case DISASSOCIATE:
18768       case EACH:
18769       case FOLLOWS:
18770       case LOGOFF:
18771       case LOGON:
18772       case NESTED:
18773       case NOAUDIT:
18774       case SCHEMA:
18775       case SERVERERROR:
18776       case SHUTDOWN:
18777       case STARTUP:
18778       case STATEMENT:
18779       case STATISTICS:
18780       case SUSPEND:
18781       case TRUNCATE:
18782       case WRAPPED:
18783       case LIBRARY:
18784       case NAME:
18785       case STRUCT:
18786       case CONTEXT:
18787       case PARAMETERS:
18788       case LENGTH:
18789       case TDO:
18790       case MAXLEN:
18791       case CHARSETID:
18792       case CHARSETFORM:
18793       case ACCEPT:
18794       case ACCESSIBLE:
18795       case COPY:
18796       case DEFINE:
18797       case DISCONNECT:
18798       case HOST:
18799       case PRINT:
18800       case QUIT:
18801       case REMARK:
18802       case UNDEFINE:
18803       case VARIABLE:
18804       case WHENEVER:
18805       case ATTACH:
18806       case CAST:
18807       case TREAT:
18808       case TRIM:
18809       case LEFT:
18810       case RIGHT:
18811       case BOTH:
18812       case EMPTY:
18813       case MULTISET:
18814       case SUBMULTISET:
18815       case LEADING:
18816       case TRAILING:
18817       case CHAR_CS:
18818       case NCHAR_CS:
18819       case DBTIMEZONE:
18820       case SESSIONTIMEZONE:
18821       case AUTHENTICATED:
18822       case LINK:
18823       case SHARED:
18824       case DIRECTORY:
18825       case USER:
18826       case IDENTIFIER:
18827       case UNSIGNED_NUMERIC_LITERAL:
18828       case CHARACTER_LITERAL:
18829       case STRING_LITERAL:
18830       case QUOTED_LITERAL:
18831         simpleNode = IsNullCondition();
18832                                       sb.append(simpleNode.getImage());
18833         break;
18834       default:
18835         jj_la1[253] = jj_gen;
18836         jj_consume_token(-1);
18837         throw new ParseException();
18838       }
18839    jjtree.closeNodeScope(jjtn000, true);
18840    jjtc000 = false;
18841  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18842     } catch (Throwable jjte000) {
18843     if (jjtc000) {
18844       jjtree.clearNodeScope(jjtn000);
18845       jjtc000 = false;
18846     } else {
18847       jjtree.popNode();
18848     }
18849     if (jjte000 instanceof RuntimeException) {
18850       {if (true) throw (RuntimeException)jjte000;}
18851     }
18852     if (jjte000 instanceof ParseException) {
18853       {if (true) throw (ParseException)jjte000;}
18854     }
18855     {if (true) throw (Error)jjte000;}
18856     } finally {
18857     if (jjtc000) {
18858       jjtree.closeNodeScope(jjtn000, true);
18859     }
18860     }
18861     throw new Error("Missing return statement in function");
18862   }
18863 
18864   final public ASTIsNullCondition IsNullCondition() throws ParseException {
18865  /*@bgen(jjtree) IsNullCondition */
18866   ASTIsNullCondition jjtn000 = new ASTIsNullCondition(this, JJTISNULLCONDITION);
18867   boolean jjtc000 = true;
18868   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18869     try {
18870       if (jj_2_46(2147483647)) {
18871         name = Name();
18872                                  sb.append(name.getImage());
18873         jj_consume_token(IS);
18874                                                                     sb.append(" IS");
18875         switch (jj_nt.kind) {
18876         case NOT:
18877           jj_consume_token(NOT);
18878                                                                                                sb.append(" NOT");
18879           break;
18880         default:
18881           jj_la1[254] = jj_gen;
18882           ;
18883         }
18884         jj_consume_token(NULL);
18885                                                                                                                             sb.append(" NULL");
18886       } else {
18887         switch (jj_nt.kind) {
18888         case 5:
18889         case REPLACE:
18890         case DEFINER:
18891         case CURRENT_USER:
18892         case LANGUAGE:
18893         case INLINE:
18894         case ADD:
18895         case AGGREGATE:
18896         case ARRAY:
18897         case AT:
18898         case ATTRIBUTE:
18899         case AUTHID:
18900         case BODY:
18901         case BULK:
18902         case BYTE:
18903         case CASCADE:
18904         case CASE:
18905         case CLOSE:
18906         case COALESCE:
18907         case COLLECT:
18908         case COLUMN:
18909         case COMMENT:
18910         case COMMIT:
18911         case CONSTRUCTOR:
18912         case CONTINUE:
18913         case CONVERT:
18914         case CURRENT:
18915         case CURSOR:
18916         case DATA:
18917         case DATE:
18918         case DAY:
18919         case DISABLE:
18920         case EDITIONABLE:
18921         case ELEMENT:
18922         case ENABLE:
18923         case ESCAPE:
18924         case EXCEPT:
18925         case EXCEPTIONS:
18926         case EXIT:
18927         case EXTERNAL:
18928         case EXTENDS:
18929         case EXTRACT:
18930         case FALSE:
18931         case FINAL:
18932         case FORCE:
18933         case FUNCTION:
18934         case GLOBAL:
18935         case HASH:
18936         case HEAP:
18937         case HOUR:
18938         case IMMEDIATE:
18939         case INDICES:
18940         case INDEXTYPE:
18941         case INDICATOR:
18942         case INSTANTIABLE:
18943         case INTERVAL:
18944         case INVALIDATE:
18945         case ISOLATION:
18946         case JAVA:
18947         case LEVEL:
18948         case LIMIT:
18949         case LOOP:
18950         case MAP:
18951         case MAX:
18952         case MEMBER:
18953         case MERGE:
18954         case MIN:
18955         case MINUTE:
18956         case MLSLABEL:
18957         case MODIFY:
18958         case MOD:
18959         case MONTH:
18960         case NATURAL:
18961         case NEW:
18962         case NEW_DOT:
18963         case NO:
18964         case NONEDITIONABLE:
18965         case NULL:
18966         case NULLIF:
18967         case OBJECT:
18968         case OID:
18969         case OPAQUE:
18970         case OPEN:
18971         case OPERATOR:
18972         case ORGANIZATION:
18973         case OTHERS:
18974         case OVERRIDING:
18975         case PACKAGE:
18976         case PARTITION:
18977         case PRESERVE:
18978         case PRIVATE:
18979         case PROCEDURE:
18980         case RANGE:
18981         case RAW:
18982         case REAL:
18983         case RECORD:
18984         case REF:
18985         case RELEASE:
18986         case RELIES_ON:
18987         case RENAME:
18988         case RESULT:
18989         case RETURN:
18990         case RETURNING:
18991         case REVERSE:
18992         case ROLLBACK:
18993         case ROW:
18994         case ROWS:
18995         case ROWID:
18996         case ROWNUM:
18997         case SAVE:
18998         case SAVEPOINT:
18999         case SECOND:
19000         case SELECT:
19001         case SELF:
19002         case SET:
19003         case SPACE:
19004         case SQL:
19005         case SQLCODE:
19006         case SQLERRM:
19007         case STATIC:
19008         case SUBTYPE:
19009         case SUBSTITUTABLE:
19010         case SUCCESSFUL:
19011         case SYSDATE:
19012         case SYS_REFCURSOR:
19013         case TEMPORARY:
19014         case TIME:
19015         case TIMESTAMP:
19016         case TIMEZONE_REGION:
19017         case TIMEZONE_ABBR:
19018         case TIMEZONE_MINUTE:
19019         case TIMEZONE_HOUR:
19020         case TRANSACTION:
19021         case TRUE:
19022         case TYPE:
19023         case UNDER:
19024         case USING:
19025         case YES:
19026         case SHOW:
19027         case A:
19028         case DOUBLE:
19029         case DEC:
19030         case PRECISION:
19031         case INT:
19032         case NUMERIC:
19033         case NCHAR:
19034         case NVARCHAR2:
19035         case STRING:
19036         case UROWID:
19037         case VARRAY:
19038         case VARYING:
19039         case BFILE:
19040         case BLOB:
19041         case CLOB:
19042         case NCLOB:
19043         case YEAR:
19044         case LOCAL:
19045         case WITH:
19046         case ZONE:
19047         case CHARACTER:
19048         case AFTER:
19049         case BEFORE:
19050         case OLD:
19051         case PARENT:
19052         case ANALYZE:
19053         case ASSOCIATE:
19054         case AUDIT:
19055         case COMPOUND:
19056         case DATABASE:
19057         case CALL:
19058         case DDL:
19059         case DISASSOCIATE:
19060         case EACH:
19061         case FOLLOWS:
19062         case LOGOFF:
19063         case LOGON:
19064         case NESTED:
19065         case NOAUDIT:
19066         case SCHEMA:
19067         case SERVERERROR:
19068         case SHUTDOWN:
19069         case STARTUP:
19070         case STATEMENT:
19071         case STATISTICS:
19072         case SUSPEND:
19073         case TRUNCATE:
19074         case WRAPPED:
19075         case LIBRARY:
19076         case NAME:
19077         case STRUCT:
19078         case CONTEXT:
19079         case PARAMETERS:
19080         case LENGTH:
19081         case TDO:
19082         case MAXLEN:
19083         case CHARSETID:
19084         case CHARSETFORM:
19085         case ACCEPT:
19086         case ACCESSIBLE:
19087         case COPY:
19088         case DEFINE:
19089         case DISCONNECT:
19090         case HOST:
19091         case PRINT:
19092         case QUIT:
19093         case REMARK:
19094         case UNDEFINE:
19095         case VARIABLE:
19096         case WHENEVER:
19097         case ATTACH:
19098         case CAST:
19099         case TREAT:
19100         case TRIM:
19101         case LEFT:
19102         case RIGHT:
19103         case BOTH:
19104         case EMPTY:
19105         case MULTISET:
19106         case SUBMULTISET:
19107         case LEADING:
19108         case TRAILING:
19109         case CHAR_CS:
19110         case NCHAR_CS:
19111         case DBTIMEZONE:
19112         case SESSIONTIMEZONE:
19113         case AUTHENTICATED:
19114         case LINK:
19115         case SHARED:
19116         case DIRECTORY:
19117         case USER:
19118         case IDENTIFIER:
19119         case UNSIGNED_NUMERIC_LITERAL:
19120         case CHARACTER_LITERAL:
19121         case STRING_LITERAL:
19122         case QUOTED_LITERAL:
19123           simpleNode = IsOfTypeCondition();
19124                 sb.append(simpleNode.getImage());
19125           break;
19126         default:
19127           jj_la1[255] = jj_gen;
19128           jj_consume_token(-1);
19129           throw new ParseException();
19130         }
19131       }
19132     jjtree.closeNodeScope(jjtn000, true);
19133     jjtc000 = false;
19134     jjtn000.setImage(sb.toString());
19135         {if (true) return jjtn000;}
19136     } catch (Throwable jjte000) {
19137     if (jjtc000) {
19138       jjtree.clearNodeScope(jjtn000);
19139       jjtc000 = false;
19140     } else {
19141       jjtree.popNode();
19142     }
19143     if (jjte000 instanceof RuntimeException) {
19144       {if (true) throw (RuntimeException)jjte000;}
19145     }
19146     if (jjte000 instanceof ParseException) {
19147       {if (true) throw (ParseException)jjte000;}
19148     }
19149     {if (true) throw (Error)jjte000;}
19150     } finally {
19151     if (jjtc000) {
19152       jjtree.closeNodeScope(jjtn000, true);
19153     }
19154     }
19155     throw new Error("Missing return statement in function");
19156   }
19157 
19158   final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
19159  /*@bgen(jjtree) IsOfTypeCondition */
19160   ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
19161   boolean jjtc000 = true;
19162   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
19163     try {
19164       if (jj_2_47(2147483647)) {
19165         name = Name();
19166                       sb.append(name.getImage());
19167         jj_consume_token(IS);
19168                                                          sb.append(" IS");
19169         switch (jj_nt.kind) {
19170         case NOT:
19171           jj_consume_token(NOT);
19172                                                                                     sb.append(" NOT");
19173           break;
19174         default:
19175           jj_la1[256] = jj_gen;
19176           ;
19177         }
19178         jj_consume_token(OF);
19179                                                                                                                sb.append(" OF");
19180         switch (jj_nt.kind) {
19181         case TYPE:
19182           jj_consume_token(TYPE);
19183           break;
19184         default:
19185           jj_la1[257] = jj_gen;
19186           ;
19187         }
19188         jj_consume_token(5);
19189         switch (jj_nt.kind) {
19190         case ONLY:
19191           jj_consume_token(ONLY);
19192           break;
19193         default:
19194           jj_la1[258] = jj_gen;
19195           ;
19196         }
19197         Name();
19198         label_61:
19199         while (true) {
19200           switch (jj_nt.kind) {
19201           case 6:
19202             ;
19203             break;
19204           default:
19205             jj_la1[259] = jj_gen;
19206             break label_61;
19207           }
19208           jj_consume_token(6);
19209           switch (jj_nt.kind) {
19210           case ONLY:
19211             jj_consume_token(ONLY);
19212             break;
19213           default:
19214             jj_la1[260] = jj_gen;
19215             ;
19216           }
19217           Name();
19218         }
19219         jj_consume_token(7);
19220       } else {
19221         switch (jj_nt.kind) {
19222         case 5:
19223         case REPLACE:
19224         case DEFINER:
19225         case CURRENT_USER:
19226         case LANGUAGE:
19227         case INLINE:
19228         case ADD:
19229         case AGGREGATE:
19230         case ARRAY:
19231         case AT:
19232         case ATTRIBUTE:
19233         case AUTHID:
19234         case BODY:
19235         case BULK:
19236         case BYTE:
19237         case CASCADE:
19238         case CASE:
19239         case CLOSE:
19240         case COALESCE:
19241         case COLLECT:
19242         case COLUMN:
19243         case COMMENT:
19244         case COMMIT:
19245         case CONSTRUCTOR:
19246         case CONTINUE:
19247         case CONVERT:
19248         case CURRENT:
19249         case CURSOR:
19250         case DATA:
19251         case DATE:
19252         case DAY:
19253         case DISABLE:
19254         case EDITIONABLE:
19255         case ELEMENT:
19256         case ENABLE:
19257         case ESCAPE:
19258         case EXCEPT:
19259         case EXCEPTIONS:
19260         case EXIT:
19261         case EXTERNAL:
19262         case EXTENDS:
19263         case EXTRACT:
19264         case FALSE:
19265         case FINAL:
19266         case FORCE:
19267         case FUNCTION:
19268         case GLOBAL:
19269         case HASH:
19270         case HEAP:
19271         case HOUR:
19272         case IMMEDIATE:
19273         case INDICES:
19274         case INDEXTYPE:
19275         case INDICATOR:
19276         case INSTANTIABLE:
19277         case INTERVAL:
19278         case INVALIDATE:
19279         case ISOLATION:
19280         case JAVA:
19281         case LEVEL:
19282         case LIMIT:
19283         case LOOP:
19284         case MAP:
19285         case MAX:
19286         case MEMBER:
19287         case MERGE:
19288         case MIN:
19289         case MINUTE:
19290         case MLSLABEL:
19291         case MODIFY:
19292         case MOD:
19293         case MONTH:
19294         case NATURAL:
19295         case NEW:
19296         case NEW_DOT:
19297         case NO:
19298         case NONEDITIONABLE:
19299         case NULL:
19300         case NULLIF:
19301         case OBJECT:
19302         case OID:
19303         case OPAQUE:
19304         case OPEN:
19305         case OPERATOR:
19306         case ORGANIZATION:
19307         case OTHERS:
19308         case OVERRIDING:
19309         case PACKAGE:
19310         case PARTITION:
19311         case PRESERVE:
19312         case PRIVATE:
19313         case PROCEDURE:
19314         case RANGE:
19315         case RAW:
19316         case REAL:
19317         case RECORD:
19318         case REF:
19319         case RELEASE:
19320         case RELIES_ON:
19321         case RENAME:
19322         case RESULT:
19323         case RETURN:
19324         case RETURNING:
19325         case REVERSE:
19326         case ROLLBACK:
19327         case ROW:
19328         case ROWS:
19329         case ROWID:
19330         case ROWNUM:
19331         case SAVE:
19332         case SAVEPOINT:
19333         case SECOND:
19334         case SELECT:
19335         case SELF:
19336         case SET:
19337         case SPACE:
19338         case SQL:
19339         case SQLCODE:
19340         case SQLERRM:
19341         case STATIC:
19342         case SUBTYPE:
19343         case SUBSTITUTABLE:
19344         case SUCCESSFUL:
19345         case SYSDATE:
19346         case SYS_REFCURSOR:
19347         case TEMPORARY:
19348         case TIME:
19349         case TIMESTAMP:
19350         case TIMEZONE_REGION:
19351         case TIMEZONE_ABBR:
19352         case TIMEZONE_MINUTE:
19353         case TIMEZONE_HOUR:
19354         case TRANSACTION:
19355         case TRUE:
19356         case TYPE:
19357         case UNDER:
19358         case USING:
19359         case YES:
19360         case SHOW:
19361         case A:
19362         case DOUBLE:
19363         case DEC:
19364         case PRECISION:
19365         case INT:
19366         case NUMERIC:
19367         case NCHAR:
19368         case NVARCHAR2:
19369         case STRING:
19370         case UROWID:
19371         case VARRAY:
19372         case VARYING:
19373         case BFILE:
19374         case BLOB:
19375         case CLOB:
19376         case NCLOB:
19377         case YEAR:
19378         case LOCAL:
19379         case WITH:
19380         case ZONE:
19381         case CHARACTER:
19382         case AFTER:
19383         case BEFORE:
19384         case OLD:
19385         case PARENT:
19386         case ANALYZE:
19387         case ASSOCIATE:
19388         case AUDIT:
19389         case COMPOUND:
19390         case DATABASE:
19391         case CALL:
19392         case DDL:
19393         case DISASSOCIATE:
19394         case EACH:
19395         case FOLLOWS:
19396         case LOGOFF:
19397         case LOGON:
19398         case NESTED:
19399         case NOAUDIT:
19400         case SCHEMA:
19401         case SERVERERROR:
19402         case SHUTDOWN:
19403         case STARTUP:
19404         case STATEMENT:
19405         case STATISTICS:
19406         case SUSPEND:
19407         case TRUNCATE:
19408         case WRAPPED:
19409         case LIBRARY:
19410         case NAME:
19411         case STRUCT:
19412         case CONTEXT:
19413         case PARAMETERS:
19414         case LENGTH:
19415         case TDO:
19416         case MAXLEN:
19417         case CHARSETID:
19418         case CHARSETFORM:
19419         case ACCEPT:
19420         case ACCESSIBLE:
19421         case COPY:
19422         case DEFINE:
19423         case DISCONNECT:
19424         case HOST:
19425         case PRINT:
19426         case QUIT:
19427         case REMARK:
19428         case UNDEFINE:
19429         case VARIABLE:
19430         case WHENEVER:
19431         case ATTACH:
19432         case CAST:
19433         case TREAT:
19434         case TRIM:
19435         case LEFT:
19436         case RIGHT:
19437         case BOTH:
19438         case EMPTY:
19439         case MULTISET:
19440         case SUBMULTISET:
19441         case LEADING:
19442         case TRAILING:
19443         case CHAR_CS:
19444         case NCHAR_CS:
19445         case DBTIMEZONE:
19446         case SESSIONTIMEZONE:
19447         case AUTHENTICATED:
19448         case LINK:
19449         case SHARED:
19450         case DIRECTORY:
19451         case USER:
19452         case IDENTIFIER:
19453         case UNSIGNED_NUMERIC_LITERAL:
19454         case CHARACTER_LITERAL:
19455         case STRING_LITERAL:
19456         case QUOTED_LITERAL:
19457           simpleNode = PrimaryExpression();
19458                                           sb.append(simpleNode.getImage());
19459           break;
19460         default:
19461           jj_la1[261] = jj_gen;
19462           jj_consume_token(-1);
19463           throw new ParseException();
19464         }
19465       }
19466     jjtree.closeNodeScope(jjtn000, true);
19467     jjtc000 = false;
19468     jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19469     } catch (Throwable jjte000) {
19470     if (jjtc000) {
19471       jjtree.clearNodeScope(jjtn000);
19472       jjtc000 = false;
19473     } else {
19474       jjtree.popNode();
19475     }
19476     if (jjte000 instanceof RuntimeException) {
19477       {if (true) throw (RuntimeException)jjte000;}
19478     }
19479     if (jjte000 instanceof ParseException) {
19480       {if (true) throw (ParseException)jjte000;}
19481     }
19482     {if (true) throw (Error)jjte000;}
19483     } finally {
19484     if (jjtc000) {
19485       jjtree.closeNodeScope(jjtn000, true);
19486     }
19487     }
19488     throw new Error("Missing return statement in function");
19489   }
19490 
19491 /**
19492  * 2006-05-23 - Matthias Hendler - Added lookahead otherwise warning encountered.
19493  *                                 Warning arised while adding methode triggerUnit(). 
19494  * 2011-04-27 - SRT - Add optional NEW Keyword to cope with Object Type constructors
19495  */
19496   final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19497  /*@bgen(jjtree) PrimaryExpression */
19498   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19499   boolean jjtc000 = true;
19500   jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19501     try {
19502       switch (jj_nt.kind) {
19503       case NEW_DOT:
19504         jj_consume_token(NEW_DOT);
19505         simpleNode = QualifiedID();
19506                                                        sb.append(" NEW."); sb.append(simpleNode.getImage());
19507         break;
19508       case 5:
19509       case REPLACE:
19510       case DEFINER:
19511       case CURRENT_USER:
19512       case LANGUAGE:
19513       case INLINE:
19514       case ADD:
19515       case AGGREGATE:
19516       case ARRAY:
19517       case AT:
19518       case ATTRIBUTE:
19519       case AUTHID:
19520       case BODY:
19521       case BULK:
19522       case BYTE:
19523       case CASCADE:
19524       case CASE:
19525       case CLOSE:
19526       case COALESCE:
19527       case COLLECT:
19528       case COLUMN:
19529       case COMMENT:
19530       case COMMIT:
19531       case CONSTRUCTOR:
19532       case CONTINUE:
19533       case CONVERT:
19534       case CURRENT:
19535       case CURSOR:
19536       case DATA:
19537       case DATE:
19538       case DAY:
19539       case DISABLE:
19540       case EDITIONABLE:
19541       case ELEMENT:
19542       case ENABLE:
19543       case ESCAPE:
19544       case EXCEPT:
19545       case EXCEPTIONS:
19546       case EXIT:
19547       case EXTERNAL:
19548       case EXTENDS:
19549       case EXTRACT:
19550       case FALSE:
19551       case FINAL:
19552       case FORCE:
19553       case FUNCTION:
19554       case GLOBAL:
19555       case HASH:
19556       case HEAP:
19557       case HOUR:
19558       case IMMEDIATE:
19559       case INDICES:
19560       case INDEXTYPE:
19561       case INDICATOR:
19562       case INSTANTIABLE:
19563       case INTERVAL:
19564       case INVALIDATE:
19565       case ISOLATION:
19566       case JAVA:
19567       case LEVEL:
19568       case LIMIT:
19569       case LOOP:
19570       case MAP:
19571       case MAX:
19572       case MEMBER:
19573       case MERGE:
19574       case MIN:
19575       case MINUTE:
19576       case MLSLABEL:
19577       case MODIFY:
19578       case MOD:
19579       case MONTH:
19580       case NATURAL:
19581       case NEW:
19582       case NO:
19583       case NONEDITIONABLE:
19584       case NULL:
19585       case NULLIF:
19586       case OBJECT:
19587       case OID:
19588       case OPAQUE:
19589       case OPEN:
19590       case OPERATOR:
19591       case ORGANIZATION:
19592       case OTHERS:
19593       case OVERRIDING:
19594       case PACKAGE:
19595       case PARTITION:
19596       case PRESERVE:
19597       case PRIVATE:
19598       case PROCEDURE:
19599       case RANGE:
19600       case RAW:
19601       case REAL:
19602       case RECORD:
19603       case REF:
19604       case RELEASE:
19605       case RELIES_ON:
19606       case RENAME:
19607       case RESULT:
19608       case RETURN:
19609       case RETURNING:
19610       case REVERSE:
19611       case ROLLBACK:
19612       case ROW:
19613       case ROWS:
19614       case ROWID:
19615       case ROWNUM:
19616       case SAVE:
19617       case SAVEPOINT:
19618       case SECOND:
19619       case SELECT:
19620       case SELF:
19621       case SET:
19622       case SPACE:
19623       case SQL:
19624       case SQLCODE:
19625       case SQLERRM:
19626       case STATIC:
19627       case SUBTYPE:
19628       case SUBSTITUTABLE:
19629       case SUCCESSFUL:
19630       case SYSDATE:
19631       case SYS_REFCURSOR:
19632       case TEMPORARY:
19633       case TIME:
19634       case TIMESTAMP:
19635       case TIMEZONE_REGION:
19636       case TIMEZONE_ABBR:
19637       case TIMEZONE_MINUTE:
19638       case TIMEZONE_HOUR:
19639       case TRANSACTION:
19640       case TRUE:
19641       case TYPE:
19642       case UNDER:
19643       case USING:
19644       case YES:
19645       case SHOW:
19646       case A:
19647       case DOUBLE:
19648       case DEC:
19649       case PRECISION:
19650       case INT:
19651       case NUMERIC:
19652       case NCHAR:
19653       case NVARCHAR2:
19654       case STRING:
19655       case UROWID:
19656       case VARRAY:
19657       case VARYING:
19658       case BFILE:
19659       case BLOB:
19660       case CLOB:
19661       case NCLOB:
19662       case YEAR:
19663       case LOCAL:
19664       case WITH:
19665       case ZONE:
19666       case CHARACTER:
19667       case AFTER:
19668       case BEFORE:
19669       case OLD:
19670       case PARENT:
19671       case ANALYZE:
19672       case ASSOCIATE:
19673       case AUDIT:
19674       case COMPOUND:
19675       case DATABASE:
19676       case CALL:
19677       case DDL:
19678       case DISASSOCIATE:
19679       case EACH:
19680       case FOLLOWS:
19681       case LOGOFF:
19682       case LOGON:
19683       case NESTED:
19684       case NOAUDIT:
19685       case SCHEMA:
19686       case SERVERERROR:
19687       case SHUTDOWN:
19688       case STARTUP:
19689       case STATEMENT:
19690       case STATISTICS:
19691       case SUSPEND:
19692       case TRUNCATE:
19693       case WRAPPED:
19694       case LIBRARY:
19695       case NAME:
19696       case STRUCT:
19697       case CONTEXT:
19698       case PARAMETERS:
19699       case LENGTH:
19700       case TDO:
19701       case MAXLEN:
19702       case CHARSETID:
19703       case CHARSETFORM:
19704       case ACCEPT:
19705       case ACCESSIBLE:
19706       case COPY:
19707       case DEFINE:
19708       case DISCONNECT:
19709       case HOST:
19710       case PRINT:
19711       case QUIT:
19712       case REMARK:
19713       case UNDEFINE:
19714       case VARIABLE:
19715       case WHENEVER:
19716       case ATTACH:
19717       case CAST:
19718       case TREAT:
19719       case TRIM:
19720       case LEFT:
19721       case RIGHT:
19722       case BOTH:
19723       case EMPTY:
19724       case MULTISET:
19725       case SUBMULTISET:
19726       case LEADING:
19727       case TRAILING:
19728       case CHAR_CS:
19729       case NCHAR_CS:
19730       case DBTIMEZONE:
19731       case SESSIONTIMEZONE:
19732       case AUTHENTICATED:
19733       case LINK:
19734       case SHARED:
19735       case DIRECTORY:
19736       case USER:
19737       case IDENTIFIER:
19738       case UNSIGNED_NUMERIC_LITERAL:
19739       case CHARACTER_LITERAL:
19740       case STRING_LITERAL:
19741       case QUOTED_LITERAL:
19742         if (jj_2_48(2147483647)) {
19743           jj_consume_token(NEW);
19744                 sb.append(" NEW ");
19745           simpleNode = PrimaryPrefix();
19746                                                                        sb.append(simpleNode.getImage());
19747         } else {
19748           switch (jj_nt.kind) {
19749           case 5:
19750           case REPLACE:
19751           case DEFINER:
19752           case CURRENT_USER:
19753           case LANGUAGE:
19754           case INLINE:
19755           case ADD:
19756           case AGGREGATE:
19757           case ARRAY:
19758           case AT:
19759           case ATTRIBUTE:
19760           case AUTHID:
19761           case BODY:
19762           case BULK:
19763           case BYTE:
19764           case CASCADE:
19765           case CASE:
19766           case CLOSE:
19767           case COALESCE:
19768           case COLLECT:
19769           case COLUMN:
19770           case COMMENT:
19771           case COMMIT:
19772           case CONSTRUCTOR:
19773           case CONTINUE:
19774           case CONVERT:
19775           case CURRENT:
19776           case CURSOR:
19777           case DATA:
19778           case DATE:
19779           case DAY:
19780           case DISABLE:
19781           case EDITIONABLE:
19782           case ELEMENT:
19783           case ENABLE:
19784           case ESCAPE:
19785           case EXCEPT:
19786           case EXCEPTIONS:
19787           case EXIT:
19788           case EXTERNAL:
19789           case EXTENDS:
19790           case EXTRACT:
19791           case FALSE:
19792           case FINAL:
19793           case FORCE:
19794           case FUNCTION:
19795           case GLOBAL:
19796           case HASH:
19797           case HEAP:
19798           case HOUR:
19799           case IMMEDIATE:
19800           case INDICES:
19801           case INDEXTYPE:
19802           case INDICATOR:
19803           case INSTANTIABLE:
19804           case INTERVAL:
19805           case INVALIDATE:
19806           case ISOLATION:
19807           case JAVA:
19808           case LEVEL:
19809           case LIMIT:
19810           case LOOP:
19811           case MAP:
19812           case MAX:
19813           case MEMBER:
19814           case MERGE:
19815           case MIN:
19816           case MINUTE:
19817           case MLSLABEL:
19818           case MODIFY:
19819           case MOD:
19820           case MONTH:
19821           case NATURAL:
19822           case NEW:
19823           case NO:
19824           case NONEDITIONABLE:
19825           case NULL:
19826           case NULLIF:
19827           case OBJECT:
19828           case OID:
19829           case OPAQUE:
19830           case OPEN:
19831           case OPERATOR:
19832           case ORGANIZATION:
19833           case OTHERS:
19834           case OVERRIDING:
19835           case PACKAGE:
19836           case PARTITION:
19837           case PRESERVE:
19838           case PRIVATE:
19839           case PROCEDURE:
19840           case RANGE:
19841           case RAW:
19842           case REAL:
19843           case RECORD:
19844           case REF:
19845           case RELEASE:
19846           case RELIES_ON:
19847           case RENAME:
19848           case RESULT:
19849           case RETURN:
19850           case RETURNING:
19851           case REVERSE:
19852           case ROLLBACK:
19853           case ROW:
19854           case ROWS:
19855           case ROWID:
19856           case ROWNUM:
19857           case SAVE:
19858           case SAVEPOINT:
19859           case SECOND:
19860           case SELECT:
19861           case SELF:
19862           case SET:
19863           case SPACE:
19864           case SQL:
19865           case SQLCODE:
19866           case SQLERRM:
19867           case STATIC:
19868           case SUBTYPE:
19869           case SUBSTITUTABLE:
19870           case SUCCESSFUL:
19871           case SYSDATE:
19872           case SYS_REFCURSOR:
19873           case TEMPORARY:
19874           case TIME:
19875           case TIMESTAMP:
19876           case TIMEZONE_REGION:
19877           case TIMEZONE_ABBR:
19878           case TIMEZONE_MINUTE:
19879           case TIMEZONE_HOUR:
19880           case TRANSACTION:
19881           case TRUE:
19882           case TYPE:
19883           case UNDER:
19884           case USING:
19885           case YES:
19886           case SHOW:
19887           case A:
19888           case DOUBLE:
19889           case DEC:
19890           case PRECISION:
19891           case INT:
19892           case NUMERIC:
19893           case NCHAR:
19894           case NVARCHAR2:
19895           case STRING:
19896           case UROWID:
19897           case VARRAY:
19898           case VARYING:
19899           case BFILE:
19900           case BLOB:
19901           case CLOB:
19902           case NCLOB:
19903           case YEAR:
19904           case LOCAL:
19905           case WITH:
19906           case ZONE:
19907           case CHARACTER:
19908           case AFTER:
19909           case BEFORE:
19910           case OLD:
19911           case PARENT:
19912           case ANALYZE:
19913           case ASSOCIATE:
19914           case AUDIT:
19915           case COMPOUND:
19916           case DATABASE:
19917           case CALL:
19918           case DDL:
19919           case DISASSOCIATE:
19920           case EACH:
19921           case FOLLOWS:
19922           case LOGOFF:
19923           case LOGON:
19924           case NESTED:
19925           case NOAUDIT:
19926           case SCHEMA:
19927           case SERVERERROR:
19928           case SHUTDOWN:
19929           case STARTUP:
19930           case STATEMENT:
19931           case STATISTICS:
19932           case SUSPEND:
19933           case TRUNCATE:
19934           case WRAPPED:
19935           case LIBRARY:
19936           case NAME:
19937           case STRUCT:
19938           case CONTEXT:
19939           case PARAMETERS:
19940           case LENGTH:
19941           case TDO:
19942           case MAXLEN:
19943           case CHARSETID:
19944           case CHARSETFORM:
19945           case ACCEPT:
19946           case ACCESSIBLE:
19947           case COPY:
19948           case DEFINE:
19949           case DISCONNECT:
19950           case HOST:
19951           case PRINT:
19952           case QUIT:
19953           case REMARK:
19954           case UNDEFINE:
19955           case VARIABLE:
19956           case WHENEVER:
19957           case ATTACH:
19958           case CAST:
19959           case TREAT:
19960           case TRIM:
19961           case LEFT:
19962           case RIGHT:
19963           case BOTH:
19964           case EMPTY:
19965           case MULTISET:
19966           case SUBMULTISET:
19967           case LEADING:
19968           case TRAILING:
19969           case CHAR_CS:
19970           case NCHAR_CS:
19971           case DBTIMEZONE:
19972           case SESSIONTIMEZONE:
19973           case AUTHENTICATED:
19974           case LINK:
19975           case SHARED:
19976           case DIRECTORY:
19977           case USER:
19978           case IDENTIFIER:
19979           case UNSIGNED_NUMERIC_LITERAL:
19980           case CHARACTER_LITERAL:
19981           case STRING_LITERAL:
19982           case QUOTED_LITERAL:
19983             simpleNode = PrimaryPrefix();
19984                                                sb.append(simpleNode.getImage());
19985             break;
19986           default:
19987             jj_la1[262] = jj_gen;
19988             jj_consume_token(-1);
19989             throw new ParseException();
19990           }
19991         }
19992         label_62:
19993         while (true) {
19994           if (jj_2_49(2)) {
19995             ;
19996           } else {
19997             break label_62;
19998           }
19999           simpleNode = PrimarySuffix();
20000                                                            sb.append(simpleNode.getImage());
20001         }
20002         break;
20003       default:
20004         jj_la1[263] = jj_gen;
20005         jj_consume_token(-1);
20006         throw new ParseException();
20007       }
20008    jjtree.closeNodeScope(jjtn000, true);
20009    jjtc000 = false;
20010  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20011     } catch (Throwable jjte000) {
20012     if (jjtc000) {
20013       jjtree.clearNodeScope(jjtn000);
20014       jjtc000 = false;
20015     } else {
20016       jjtree.popNode();
20017     }
20018     if (jjte000 instanceof RuntimeException) {
20019       {if (true) throw (RuntimeException)jjte000;}
20020     }
20021     if (jjte000 instanceof ParseException) {
20022       {if (true) throw (ParseException)jjte000;}
20023     }
20024     {if (true) throw (Error)jjte000;}
20025     } finally {
20026     if (jjtc000) {
20027       jjtree.closeNodeScope(jjtn000, true);
20028     }
20029     }
20030     throw new Error("Missing return statement in function");
20031   }
20032 
20033   final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
20034  /*@bgen(jjtree) PrimaryPrefix */
20035   ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
20036   boolean jjtc000 = true;
20037   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
20038     try {
20039       switch (jj_nt.kind) {
20040       case DATE:
20041       case FALSE:
20042       case INTERVAL:
20043       case NULL:
20044       case TIMESTAMP:
20045       case TRUE:
20046       case UNSIGNED_NUMERIC_LITERAL:
20047       case CHARACTER_LITERAL:
20048       case STRING_LITERAL:
20049         simpleNode = Literal();
20050                                sb.append(simpleNode.getImage()) ;
20051         break;
20052       default:
20053         jj_la1[265] = jj_gen;
20054         if (jj_2_50(2147483647)) {
20055           simpleNode = MultiSetCondition();
20056         } else if (jj_2_51(2147483647)) {
20057           simpleNode = TrimExpression();
20058         } else if (jj_2_52(2147483647)) {
20059           simpleNode = CaseExpression();
20060                                                                  sb.append(simpleNode.getImage()) ;
20061         } else if (jj_2_53(2147483647)) {
20062           simpleNode = ObjectExpression();
20063                                                                        sb.append(simpleNode.getImage()) ;
20064         } else {
20065           switch (jj_nt.kind) {
20066           case REPLACE:
20067           case DEFINER:
20068           case CURRENT_USER:
20069           case LANGUAGE:
20070           case INLINE:
20071           case ADD:
20072           case AGGREGATE:
20073           case ARRAY:
20074           case AT:
20075           case ATTRIBUTE:
20076           case AUTHID:
20077           case BODY:
20078           case BULK:
20079           case BYTE:
20080           case CASCADE:
20081           case CLOSE:
20082           case COALESCE:
20083           case COLLECT:
20084           case COLUMN:
20085           case COMMENT:
20086           case COMMIT:
20087           case CONSTRUCTOR:
20088           case CONTINUE:
20089           case CONVERT:
20090           case CURRENT:
20091           case CURSOR:
20092           case DATA:
20093           case DAY:
20094           case DISABLE:
20095           case EDITIONABLE:
20096           case ELEMENT:
20097           case ENABLE:
20098           case ESCAPE:
20099           case EXCEPT:
20100           case EXCEPTIONS:
20101           case EXIT:
20102           case EXTERNAL:
20103           case EXTENDS:
20104           case EXTRACT:
20105           case FALSE:
20106           case FINAL:
20107           case FORCE:
20108           case FUNCTION:
20109           case GLOBAL:
20110           case HASH:
20111           case HEAP:
20112           case HOUR:
20113           case IMMEDIATE:
20114           case INDICES:
20115           case INDEXTYPE:
20116           case INDICATOR:
20117           case INSTANTIABLE:
20118           case INTERVAL:
20119           case INVALIDATE:
20120           case ISOLATION:
20121           case JAVA:
20122           case LEVEL:
20123           case LIMIT:
20124           case LOOP:
20125           case MAP:
20126           case MAX:
20127           case MEMBER:
20128           case MERGE:
20129           case MIN:
20130           case MINUTE:
20131           case MLSLABEL:
20132           case MODIFY:
20133           case MOD:
20134           case MONTH:
20135           case NATURAL:
20136           case NEW:
20137           case NO:
20138           case NONEDITIONABLE:
20139           case NULLIF:
20140           case OBJECT:
20141           case OID:
20142           case OPAQUE:
20143           case OPEN:
20144           case OPERATOR:
20145           case ORGANIZATION:
20146           case OTHERS:
20147           case OVERRIDING:
20148           case PACKAGE:
20149           case PARTITION:
20150           case PRESERVE:
20151           case PRIVATE:
20152           case PROCEDURE:
20153           case RANGE:
20154           case RAW:
20155           case REAL:
20156           case RECORD:
20157           case REF:
20158           case RELEASE:
20159           case RELIES_ON:
20160           case RENAME:
20161           case RESULT:
20162           case RETURN:
20163           case RETURNING:
20164           case REVERSE:
20165           case ROLLBACK:
20166           case ROW:
20167           case ROWS:
20168           case ROWID:
20169           case ROWNUM:
20170           case SAVE:
20171           case SAVEPOINT:
20172           case SECOND:
20173           case SELF:
20174           case SET:
20175           case SPACE:
20176           case SQL:
20177           case SQLCODE:
20178           case SQLERRM:
20179           case STATIC:
20180           case SUBTYPE:
20181           case SUBSTITUTABLE:
20182           case SUCCESSFUL:
20183           case SYSDATE:
20184           case SYS_REFCURSOR:
20185           case TEMPORARY:
20186           case TIME:
20187           case TIMESTAMP:
20188           case TIMEZONE_REGION:
20189           case TIMEZONE_ABBR:
20190           case TIMEZONE_MINUTE:
20191           case TIMEZONE_HOUR:
20192           case TRANSACTION:
20193           case TRUE:
20194           case TYPE:
20195           case UNDER:
20196           case USING:
20197           case YES:
20198           case SHOW:
20199           case A:
20200           case DOUBLE:
20201           case DEC:
20202           case PRECISION:
20203           case INT:
20204           case NUMERIC:
20205           case NCHAR:
20206           case NVARCHAR2:
20207           case STRING:
20208           case UROWID:
20209           case VARRAY:
20210           case VARYING:
20211           case BFILE:
20212           case BLOB:
20213           case CLOB:
20214           case NCLOB:
20215           case YEAR:
20216           case LOCAL:
20217           case ZONE:
20218           case CHARACTER:
20219           case AFTER:
20220           case BEFORE:
20221           case OLD:
20222           case PARENT:
20223           case ANALYZE:
20224           case ASSOCIATE:
20225           case AUDIT:
20226           case COMPOUND:
20227           case DATABASE:
20228           case CALL:
20229           case DDL:
20230           case DISASSOCIATE:
20231           case EACH:
20232           case FOLLOWS:
20233           case LOGOFF:
20234           case LOGON:
20235           case NESTED:
20236           case NOAUDIT:
20237           case SCHEMA:
20238           case SERVERERROR:
20239           case SHUTDOWN:
20240           case STARTUP:
20241           case STATEMENT:
20242           case STATISTICS:
20243           case SUSPEND:
20244           case TRUNCATE:
20245           case WRAPPED:
20246           case LIBRARY:
20247           case NAME:
20248           case STRUCT:
20249           case CONTEXT:
20250           case PARAMETERS:
20251           case LENGTH:
20252           case TDO:
20253           case MAXLEN:
20254           case CHARSETID:
20255           case CHARSETFORM:
20256           case ACCEPT:
20257           case ACCESSIBLE:
20258           case COPY:
20259           case DEFINE:
20260           case DISCONNECT:
20261           case HOST:
20262           case PRINT:
20263           case QUIT:
20264           case REMARK:
20265           case UNDEFINE:
20266           case VARIABLE:
20267           case WHENEVER:
20268           case ATTACH:
20269           case CAST:
20270           case TREAT:
20271           case TRIM:
20272           case LEFT:
20273           case RIGHT:
20274           case BOTH:
20275           case EMPTY:
20276           case MULTISET:
20277           case SUBMULTISET:
20278           case LEADING:
20279           case TRAILING:
20280           case CHAR_CS:
20281           case NCHAR_CS:
20282           case DBTIMEZONE:
20283           case SESSIONTIMEZONE:
20284           case AUTHENTICATED:
20285           case LINK:
20286           case SHARED:
20287           case DIRECTORY:
20288           case USER:
20289           case IDENTIFIER:
20290           case QUOTED_LITERAL:
20291             simpleNode = Name();
20292                            sb.append(simpleNode.getImage()) ;
20293             break;
20294           default:
20295             jj_la1[266] = jj_gen;
20296             if (jj_2_54(2147483647)) {
20297               jj_consume_token(SELECT);
20298                                   sb.append("SELECT ...");
20299               Skip2NextTerminator(null,";");
20300             } else if (jj_2_55(2147483647)) {
20301               jj_consume_token(5);
20302                                     sb.append("(SELECT ...");
20303               Skip2NextTerminator("(",")");
20304               jj_consume_token(7);
20305             } else if (jj_2_56(2147483647)) {
20306               jj_consume_token(WITH);
20307                               sb.append("WITH ...");
20308               Skip2NextTerminator(null,";");
20309             } else if (jj_2_57(2147483647)) {
20310               jj_consume_token(5);
20311                                   sb.append("(WITH ...");
20312               Skip2NextTerminator("(",")");
20313               jj_consume_token(7);
20314             } else {
20315               switch (jj_nt.kind) {
20316               case 5:
20317                 jj_consume_token(5);
20318           sb.append("(");
20319                 simpleNode = Expression();
20320                                 sb.append(simpleNode.getImage());
20321                 label_63:
20322                 while (true) {
20323                   switch (jj_nt.kind) {
20324                   case 6:
20325                     ;
20326                     break;
20327                   default:
20328                     jj_la1[264] = jj_gen;
20329                     break label_63;
20330                   }
20331                   jj_consume_token(6);
20332            sb.append(", ");
20333                   simpleNode = Expression();
20334                                   sb.append(simpleNode.getImage());
20335                 }
20336                 jj_consume_token(7);
20337          sb.append(")");
20338                 break;
20339               default:
20340                 jj_la1[267] = jj_gen;
20341                 jj_consume_token(-1);
20342                 throw new ParseException();
20343               }
20344             }
20345           }
20346         }
20347       }
20348    jjtree.closeNodeScope(jjtn000, true);
20349    jjtc000 = false;
20350  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20351     } catch (Throwable jjte000) {
20352   if (jjtc000) {
20353     jjtree.clearNodeScope(jjtn000);
20354     jjtc000 = false;
20355   } else {
20356     jjtree.popNode();
20357   }
20358   if (jjte000 instanceof RuntimeException) {
20359     {if (true) throw (RuntimeException)jjte000;}
20360   }
20361   if (jjte000 instanceof ParseException) {
20362     {if (true) throw (ParseException)jjte000;}
20363   }
20364   {if (true) throw (Error)jjte000;}
20365     } finally {
20366   if (jjtc000) {
20367     jjtree.closeNodeScope(jjtn000, true);
20368   }
20369     }
20370     throw new Error("Missing return statement in function");
20371   }
20372 
20373   final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20374  /*@bgen(jjtree) PrimarySuffix */
20375   ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20376   boolean jjtc000 = true;
20377   jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20378     try {
20379       switch (jj_nt.kind) {
20380       case 3:
20381         jj_consume_token(3);
20382          sb.append(".");
20383         suffixNode = QualifiedID();
20384                                                            sb.append(suffixNode.toString()) ;
20385         break;
20386       case 2:
20387         jj_consume_token(2);
20388          sb.append("@");
20389         suffixNode = QualifiedID();
20390                                                            sb.append(suffixNode.toString()) ;
20391         break;
20392       case AT:
20393         jj_consume_token(AT);
20394           sb.append(" "); sb.append(token.image.toUpperCase());
20395         switch (jj_nt.kind) {
20396         case LOCAL:
20397           jj_consume_token(LOCAL);
20398                       sb.append(" "); sb.append(token.image.toUpperCase());
20399           break;
20400         case TIME:
20401           jj_consume_token(TIME);
20402           jj_consume_token(ZONE);
20403                                sb.append(" TIME ZONE");
20404           switch (jj_nt.kind) {
20405           case DBTIMEZONE:
20406             jj_consume_token(DBTIMEZONE);
20407                                   sb.append(" "); sb.append(token.image.toUpperCase());
20408             break;
20409           case SESSIONTIMEZONE:
20410             jj_consume_token(SESSIONTIMEZONE);
20411                                        sb.append(" "); sb.append(token.image.toUpperCase());
20412             break;
20413           case STRING_LITERAL:
20414             suffixNode = StringLiteral();
20415                                                   sb.append(" "); sb.append(suffixNode.toString());
20416             break;
20417           case 5:
20418           case 16:
20419           case 17:
20420           case REPLACE:
20421           case DEFINER:
20422           case CURRENT_USER:
20423           case LANGUAGE:
20424           case INLINE:
20425           case ADD:
20426           case AGGREGATE:
20427           case ARRAY:
20428           case AT:
20429           case ATTRIBUTE:
20430           case AUTHID:
20431           case BODY:
20432           case BULK:
20433           case BYTE:
20434           case CASCADE:
20435           case CASE:
20436           case CLOSE:
20437           case COALESCE:
20438           case COLLECT:
20439           case COLUMN:
20440           case COMMENT:
20441           case COMMIT:
20442           case CONSTRUCTOR:
20443           case CONTINUE:
20444           case CONVERT:
20445           case CURRENT:
20446           case CURSOR:
20447           case DATA:
20448           case DATE:
20449           case DAY:
20450           case DISABLE:
20451           case EDITIONABLE:
20452           case ELEMENT:
20453           case ENABLE:
20454           case ESCAPE:
20455           case EXCEPT:
20456           case EXCEPTIONS:
20457           case EXIT:
20458           case EXTERNAL:
20459           case EXTENDS:
20460           case EXTRACT:
20461           case FALSE:
20462           case FINAL:
20463           case FORCE:
20464           case FUNCTION:
20465           case GLOBAL:
20466           case HASH:
20467           case HEAP:
20468           case HOUR:
20469           case IMMEDIATE:
20470           case INDICES:
20471           case INDEXTYPE:
20472           case INDICATOR:
20473           case INSTANTIABLE:
20474           case INTERVAL:
20475           case INVALIDATE:
20476           case ISOLATION:
20477           case JAVA:
20478           case LEVEL:
20479           case LIMIT:
20480           case LOOP:
20481           case MAP:
20482           case MAX:
20483           case MEMBER:
20484           case MERGE:
20485           case MIN:
20486           case MINUTE:
20487           case MLSLABEL:
20488           case MODIFY:
20489           case MOD:
20490           case MONTH:
20491           case NATURAL:
20492           case NEW:
20493           case NEW_DOT:
20494           case NO:
20495           case NONEDITIONABLE:
20496           case NOT:
20497           case NULL:
20498           case NULLIF:
20499           case OBJECT:
20500           case OID:
20501           case OPAQUE:
20502           case OPEN:
20503           case OPERATOR:
20504           case ORGANIZATION:
20505           case OTHERS:
20506           case OVERRIDING:
20507           case PACKAGE:
20508           case PARTITION:
20509           case PRESERVE:
20510           case PRIVATE:
20511           case PROCEDURE:
20512           case RANGE:
20513           case RAW:
20514           case REAL:
20515           case RECORD:
20516           case REF:
20517           case RELEASE:
20518           case RELIES_ON:
20519           case RENAME:
20520           case RESULT:
20521           case RETURN:
20522           case RETURNING:
20523           case REVERSE:
20524           case ROLLBACK:
20525           case ROW:
20526           case ROWS:
20527           case ROWID:
20528           case ROWNUM:
20529           case SAVE:
20530           case SAVEPOINT:
20531           case SECOND:
20532           case SELECT:
20533           case SELF:
20534           case SET:
20535           case SPACE:
20536           case SQL:
20537           case SQLCODE:
20538           case SQLERRM:
20539           case STATIC:
20540           case SUBTYPE:
20541           case SUBSTITUTABLE:
20542           case SUCCESSFUL:
20543           case SYSDATE:
20544           case SYS_REFCURSOR:
20545           case TEMPORARY:
20546           case TIME:
20547           case TIMESTAMP:
20548           case TIMEZONE_REGION:
20549           case TIMEZONE_ABBR:
20550           case TIMEZONE_MINUTE:
20551           case TIMEZONE_HOUR:
20552           case TRANSACTION:
20553           case TRUE:
20554           case TYPE:
20555           case UNDER:
20556           case USING:
20557           case YES:
20558           case SHOW:
20559           case A:
20560           case DOUBLE:
20561           case DEC:
20562           case PRECISION:
20563           case INT:
20564           case NUMERIC:
20565           case NCHAR:
20566           case NVARCHAR2:
20567           case STRING:
20568           case UROWID:
20569           case VARRAY:
20570           case VARYING:
20571           case BFILE:
20572           case BLOB:
20573           case CLOB:
20574           case NCLOB:
20575           case YEAR:
20576           case LOCAL:
20577           case WITH:
20578           case ZONE:
20579           case CHARACTER:
20580           case AFTER:
20581           case BEFORE:
20582           case OLD:
20583           case PARENT:
20584           case CC_IF:
20585           case ANALYZE:
20586           case ASSOCIATE:
20587           case AUDIT:
20588           case COMPOUND:
20589           case DATABASE:
20590           case CALL:
20591           case DDL:
20592           case DISASSOCIATE:
20593           case EACH:
20594           case FOLLOWS:
20595           case LOGOFF:
20596           case LOGON:
20597           case NESTED:
20598           case NOAUDIT:
20599           case SCHEMA:
20600           case SERVERERROR:
20601           case SHUTDOWN:
20602           case STARTUP:
20603           case STATEMENT:
20604           case STATISTICS:
20605           case SUSPEND:
20606           case TRUNCATE:
20607           case WRAPPED:
20608           case LIBRARY:
20609           case NAME:
20610           case STRUCT:
20611           case CONTEXT:
20612           case PARAMETERS:
20613           case LENGTH:
20614           case TDO:
20615           case MAXLEN:
20616           case CHARSETID:
20617           case CHARSETFORM:
20618           case ACCEPT:
20619           case ACCESSIBLE:
20620           case COPY:
20621           case DEFINE:
20622           case DISCONNECT:
20623           case HOST:
20624           case PRINT:
20625           case QUIT:
20626           case REMARK:
20627           case UNDEFINE:
20628           case VARIABLE:
20629           case WHENEVER:
20630           case ATTACH:
20631           case CAST:
20632           case TREAT:
20633           case TRIM:
20634           case LEFT:
20635           case RIGHT:
20636           case BOTH:
20637           case EMPTY:
20638           case MULTISET:
20639           case SUBMULTISET:
20640           case LEADING:
20641           case TRAILING:
20642           case CHAR_CS:
20643           case NCHAR_CS:
20644           case AUTHENTICATED:
20645           case LINK:
20646           case SHARED:
20647           case DIRECTORY:
20648           case USER:
20649           case IDENTIFIER:
20650           case UNSIGNED_NUMERIC_LITERAL:
20651           case CHARACTER_LITERAL:
20652           case QUOTED_LITERAL:
20653             suffixNode = Expression();
20654                                                sb.append(" "); sb.append(suffixNode.toString());
20655             break;
20656           default:
20657             jj_la1[268] = jj_gen;
20658             jj_consume_token(-1);
20659             throw new ParseException();
20660           }
20661           break;
20662         default:
20663           jj_la1[269] = jj_gen;
20664           jj_consume_token(-1);
20665           throw new ParseException();
20666         }
20667         break;
20668       case 5:
20669         arguments = Arguments();
20670                                sb.append(arguments) ;
20671         break;
20672       default:
20673         jj_la1[270] = jj_gen;
20674         jj_consume_token(-1);
20675         throw new ParseException();
20676       }
20677    jjtree.closeNodeScope(jjtn000, true);
20678    jjtc000 = false;
20679  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20680     } catch (Throwable jjte000) {
20681     if (jjtc000) {
20682       jjtree.clearNodeScope(jjtn000);
20683       jjtc000 = false;
20684     } else {
20685       jjtree.popNode();
20686     }
20687     if (jjte000 instanceof RuntimeException) {
20688       {if (true) throw (RuntimeException)jjte000;}
20689     }
20690     if (jjte000 instanceof ParseException) {
20691       {if (true) throw (ParseException)jjte000;}
20692     }
20693     {if (true) throw (Error)jjte000;}
20694     } finally {
20695     if (jjtc000) {
20696       jjtree.closeNodeScope(jjtn000, true);
20697     }
20698     }
20699     throw new Error("Missing return statement in function");
20700   }
20701 
20702   final public ASTLiteral Literal() throws ParseException {
20703  /*@bgen(jjtree) Literal */
20704  ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20705  boolean jjtc000 = true;
20706  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20707  Token t = null ;
20708     try {
20709       switch (jj_nt.kind) {
20710       case UNSIGNED_NUMERIC_LITERAL:
20711         simpleNode = NumericLiteral();
20712         break;
20713       case CHARACTER_LITERAL:
20714         t = jj_consume_token(CHARACTER_LITERAL);
20715         break;
20716       case STRING_LITERAL:
20717         //<STRING_LITERAL> {literal = token.toString(); }
20718           simpleNode = StringLiteral();
20719         break;
20720       case FALSE:
20721       case TRUE:
20722         simpleNode = BooleanLiteral();
20723         break;
20724       case NULL:
20725         simpleNode = NullLiteral();
20726         break;
20727       case DATE:
20728       case INTERVAL:
20729       case TIMESTAMP:
20730         simpleNode = DateTimeLiteral();
20731         break;
20732       default:
20733         jj_la1[271] = jj_gen;
20734         jj_consume_token(-1);
20735         throw new ParseException();
20736       }
20737    jjtree.closeNodeScope(jjtn000, true);
20738    jjtc000 = false;
20739    if (null != simpleNode)
20740    {
20741      jjtn000.setImage( simpleNode.getImage() ) ;
20742    }
20743    else if (null != t)
20744    {
20745      jjtn000.setImage( t.image ) ;
20746    }
20747    {if (true) return jjtn000 ;}
20748     } catch (Throwable jjte000) {
20749     if (jjtc000) {
20750       jjtree.clearNodeScope(jjtn000);
20751       jjtc000 = false;
20752     } else {
20753       jjtree.popNode();
20754     }
20755     if (jjte000 instanceof RuntimeException) {
20756       {if (true) throw (RuntimeException)jjte000;}
20757     }
20758     if (jjte000 instanceof ParseException) {
20759       {if (true) throw (ParseException)jjte000;}
20760     }
20761     {if (true) throw (Error)jjte000;}
20762     } finally {
20763     if (jjtc000) {
20764       jjtree.closeNodeScope(jjtn000, true);
20765     }
20766     }
20767     throw new Error("Missing return statement in function");
20768   }
20769 
20770   final public ASTStringLiteral StringLiteral() throws ParseException {
20771  /*@bgen(jjtree) StringLiteral */
20772         ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20773         boolean jjtc000 = true;
20774         jjtree.openNodeScope(jjtn000);Token thisToken = null;
20775         StringBuilder literal = new StringBuilder() ;
20776         char startDelimiter ;
20777         char endDelimiter ;
20778         String terminator = null;
20779     try {
20780       thisToken = jj_consume_token(STRING_LITERAL);
20781    literal.append(thisToken.image);
20782    /*
20783    This might be Q-Quoted string and this might be only a partial string
20784    The token will only match up to the first single quote.
20785    The code below appends any remaining part, theh returns the complete string
20786    */
20787    if (thisToken.image.toUpperCase().startsWith("Q'")
20788        && thisToken.image.length() > 2
20789       )
20790    {
20791    // Get the first token of the string so that the delimiter can be identified
20792 
20793      startDelimiter= thisToken.image.charAt(2) ;
20794      /*
20795      if the start delimiter is one of [, {, <, or (, the end delimiter
20796      is the corresponding closing character
20797      */
20798      switch (startDelimiter)
20799      {
20800       case '<' : endDelimiter = '>' ; break ;
20801       case '{' : endDelimiter = '}' ;  break ;
20802       case '(' : endDelimiter = ')' ;  break ;
20803       case '[' : endDelimiter = ']' ;  break ;
20804       default: endDelimiter = startDelimiter ;
20805      }
20806 
20807      terminator = new String(endDelimiter + "'");
20808      if (!thisToken.image.endsWith(terminator))
20809      {
20810        //Loop until we find atoken that ends with a single-quote precede by the terminator
20811        literal.append(ReadPastNextOccurrence(terminator));
20812      }
20813    }
20814    jjtree.closeNodeScope(jjtn000, true);
20815    jjtc000 = false;
20816    jjtn000.setImage(literal.toString()) ;  jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20817     } finally {
20818    if (jjtc000) {
20819      jjtree.closeNodeScope(jjtn000, true);
20820    }
20821     }
20822     throw new Error("Missing return statement in function");
20823   }
20824 
20825   final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20826  /*@bgen(jjtree) BooleanLiteral */
20827   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20828   boolean jjtc000 = true;
20829   jjtree.openNodeScope(jjtn000);
20830     try {
20831       switch (jj_nt.kind) {
20832       case TRUE:
20833         jj_consume_token(TRUE);
20834         break;
20835       case FALSE:
20836         jj_consume_token(FALSE);
20837         break;
20838       default:
20839         jj_la1[272] = jj_gen;
20840         jj_consume_token(-1);
20841         throw new ParseException();
20842       }
20843     jjtree.closeNodeScope(jjtn000, true);
20844     jjtc000 = false;
20845    jjtn000.setImage(token.image) ;
20846    {if (true) return jjtn000;}
20847     } finally {
20848    if (jjtc000) {
20849      jjtree.closeNodeScope(jjtn000, true);
20850    }
20851     }
20852     throw new Error("Missing return statement in function");
20853   }
20854 
20855   final public ASTNullLiteral NullLiteral() throws ParseException {
20856  /*@bgen(jjtree) NullLiteral */
20857   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20858   boolean jjtc000 = true;
20859   jjtree.openNodeScope(jjtn000);
20860     try {
20861       jj_consume_token(NULL);
20862    jjtree.closeNodeScope(jjtn000, true);
20863    jjtc000 = false;
20864   jjtn000.setImage(token.image) ;
20865   {if (true) return jjtn000 ;}
20866     } finally {
20867     if (jjtc000) {
20868       jjtree.closeNodeScope(jjtn000, true);
20869     }
20870     }
20871     throw new Error("Missing return statement in function");
20872   }
20873 
20874   final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20875  /*@bgen(jjtree) MultiSetCondition */
20876   ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20877   boolean jjtc000 = true;
20878   jjtree.openNodeScope(jjtn000);
20879     try {
20880       switch (jj_nt.kind) {
20881       case A:
20882         jj_consume_token(A);
20883         jj_consume_token(SET);
20884         break;
20885       case EMPTY:
20886         jj_consume_token(EMPTY);
20887         break;
20888       default:
20889         jj_la1[273] = jj_gen;
20890         jj_consume_token(-1);
20891         throw new ParseException();
20892       }
20893    jjtree.closeNodeScope(jjtn000, true);
20894    jjtc000 = false;
20895   {if (true) return jjtn000;}
20896     } finally {
20897     if (jjtc000) {
20898       jjtree.closeNodeScope(jjtn000, true);
20899     }
20900     }
20901     throw new Error("Missing return statement in function");
20902   }
20903 
20904 /** Recognizes a numeric literal.
20905 * This may look like token, but it isn't. Not atomic enough.
20906 * E.g. "+1" would be valid literal, which make parsing of "i+1" impossible
20907 * (here, we have tokens "i", "+" and "1")
20908 */
20909   final public ASTNumericLiteral NumericLiteral() throws ParseException {
20910  /*@bgen(jjtree) NumericLiteral */
20911  ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20912  boolean jjtc000 = true;
20913  jjtree.openNodeScope(jjtn000);Token t = null ;
20914     try {
20915       //Essentially unchanged, as it previouly returned a Token 
20916                       t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20917           jjtree.closeNodeScope(jjtn000, true);
20918           jjtc000 = false;
20919          jjtn000.setImage(t.image) ;
20920          {if (true) return jjtn000;}
20921     } finally {
20922           if (jjtc000) {
20923             jjtree.closeNodeScope(jjtn000, true);
20924           }
20925     }
20926     throw new Error("Missing return statement in function");
20927   }
20928 
20929 /** This cannot be a token because these are valid labels '<< next_msg >>", '<<"OUTER LOOP">>'  
20930 */
20931   final public ASTLabel Label() throws ParseException {
20932  /*@bgen(jjtree) Label */
20933  ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20934  boolean jjtc000 = true;
20935  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20936     try {
20937       jj_consume_token(21);
20938       simpleNode = UnqualifiedID();
20939       jj_consume_token(22);
20940           jjtree.closeNodeScope(jjtn000, true);
20941           jjtc000 = false;
20942         jjtn000.setImage( simpleNode.getImage() ) ;
20943         {if (true) return jjtn000;}
20944     } catch (Throwable jjte000) {
20945           if (jjtc000) {
20946             jjtree.clearNodeScope(jjtn000);
20947             jjtc000 = false;
20948           } else {
20949             jjtree.popNode();
20950           }
20951           if (jjte000 instanceof RuntimeException) {
20952             {if (true) throw (RuntimeException)jjte000;}
20953           }
20954           if (jjte000 instanceof ParseException) {
20955             {if (true) throw (ParseException)jjte000;}
20956           }
20957           {if (true) throw (Error)jjte000;}
20958     } finally {
20959           if (jjtc000) {
20960             jjtree.closeNodeScope(jjtn000, true);
20961           }
20962     }
20963     throw new Error("Missing return statement in function");
20964   }
20965 
20966   final public ASTName Name() throws ParseException {
20967  /*@bgen(jjtree) Name */
20968  ASTName jjtn000 = new ASTName(this, JJTNAME);
20969  boolean jjtc000 = true;
20970  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20971  StringBuilder sb = new StringBuilder();
20972     try {
20973       simpleNode = UnqualifiedID();
20974                                    sb.append(simpleNode.getImage()) ;
20975       label_64:
20976       while (true) {
20977         if (jj_2_58(2)) {
20978           ;
20979         } else {
20980           break label_64;
20981         }
20982         switch (jj_nt.kind) {
20983         case 3:
20984           jj_consume_token(3);
20985             sb.append(".") ;
20986           break;
20987         case 11:
20988           jj_consume_token(11);
20989                                        sb.append("%") ;
20990           break;
20991         default:
20992           jj_la1[274] = jj_gen;
20993           jj_consume_token(-1);
20994           throw new ParseException();
20995         }
20996         //QualifiedID() 
20997             simpleNode = QualifiedID();
20998                                   sb.append(simpleNode.getImage()) ;
20999       }
21000     jjtree.closeNodeScope(jjtn000, true);
21001     jjtc000 = false;
21002   jjtn000.setImage(sb.toString()) ;
21003   {if (true) return jjtn000;}
21004     } catch (Throwable jjte000) {
21005     if (jjtc000) {
21006       jjtree.clearNodeScope(jjtn000);
21007       jjtc000 = false;
21008     } else {
21009       jjtree.popNode();
21010     }
21011     if (jjte000 instanceof RuntimeException) {
21012       {if (true) throw (RuntimeException)jjte000;}
21013     }
21014     if (jjte000 instanceof ParseException) {
21015       {if (true) throw (ParseException)jjte000;}
21016     }
21017     {if (true) throw (Error)jjte000;}
21018     } finally {
21019     if (jjtc000) {
21020       jjtree.closeNodeScope(jjtn000, true);
21021     }
21022     }
21023     throw new Error("Missing return statement in function");
21024   }
21025 
21026   final public ASTQualifiedName QualifiedName() throws ParseException {
21027  /*@bgen(jjtree) QualifiedName */
21028  ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
21029  boolean jjtc000 = true;
21030  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21031  StringBuilder sb = new StringBuilder();
21032     try {
21033       simpleNode = UnqualifiedID();
21034                                         sb.append(simpleNode.getImage()) ;
21035       label_65:
21036       while (true) {
21037         switch (jj_nt.kind) {
21038         case 3:
21039           ;
21040           break;
21041         default:
21042           jj_la1[275] = jj_gen;
21043           break label_65;
21044         }
21045         jj_consume_token(3);
21046         simpleNode = QualifiedID();
21047                                               sb.append(".") ; sb.append(simpleNode.getImage()) ;
21048       }
21049           jjtree.closeNodeScope(jjtn000, true);
21050           jjtc000 = false;
21051          jjtn000.setImage(sb.toString()) ;
21052          {if (true) return jjtn000 ;}
21053     } catch (Throwable jjte000) {
21054           if (jjtc000) {
21055             jjtree.clearNodeScope(jjtn000);
21056             jjtc000 = false;
21057           } else {
21058             jjtree.popNode();
21059           }
21060           if (jjte000 instanceof RuntimeException) {
21061             {if (true) throw (RuntimeException)jjte000;}
21062           }
21063           if (jjte000 instanceof ParseException) {
21064             {if (true) throw (ParseException)jjte000;}
21065           }
21066           {if (true) throw (Error)jjte000;}
21067     } finally {
21068           if (jjtc000) {
21069             jjtree.closeNodeScope(jjtn000, true);
21070           }
21071     }
21072     throw new Error("Missing return statement in function");
21073   }
21074 
21075   final public ASTArguments Arguments() throws ParseException {
21076  /*@bgen(jjtree) Arguments */
21077   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
21078   boolean jjtc000 = true;
21079   jjtree.openNodeScope(jjtn000);
21080     try {
21081       jj_consume_token(5);
21082       switch (jj_nt.kind) {
21083       case 5:
21084       case 16:
21085       case 17:
21086       case REPLACE:
21087       case DEFINER:
21088       case CURRENT_USER:
21089       case LANGUAGE:
21090       case INLINE:
21091       case ADD:
21092       case AGGREGATE:
21093       case ARRAY:
21094       case AT:
21095       case ATTRIBUTE:
21096       case AUTHID:
21097       case BODY:
21098       case BULK:
21099       case BYTE:
21100       case CASCADE:
21101       case CASE:
21102       case CLOSE:
21103       case COALESCE:
21104       case COLLECT:
21105       case COLUMN:
21106       case COMMENT:
21107       case COMMIT:
21108       case CONSTRUCTOR:
21109       case CONTINUE:
21110       case CONVERT:
21111       case CURRENT:
21112       case CURSOR:
21113       case DATA:
21114       case DATE:
21115       case DAY:
21116       case DISABLE:
21117       case EDITIONABLE:
21118       case ELEMENT:
21119       case ENABLE:
21120       case ESCAPE:
21121       case EXCEPT:
21122       case EXCEPTIONS:
21123       case EXIT:
21124       case EXTERNAL:
21125       case EXTENDS:
21126       case EXTRACT:
21127       case FALSE:
21128       case FINAL:
21129       case FORCE:
21130       case FUNCTION:
21131       case GLOBAL:
21132       case HASH:
21133       case HEAP:
21134       case HOUR:
21135       case IMMEDIATE:
21136       case INDICES:
21137       case INDEXTYPE:
21138       case INDICATOR:
21139       case INSTANTIABLE:
21140       case INTERVAL:
21141       case INVALIDATE:
21142       case ISOLATION:
21143       case JAVA:
21144       case LEVEL:
21145       case LIMIT:
21146       case LOOP:
21147       case MAP:
21148       case MAX:
21149       case MEMBER:
21150       case MERGE:
21151       case MIN:
21152       case MINUTE:
21153       case MLSLABEL:
21154       case MODIFY:
21155       case MOD:
21156       case MONTH:
21157       case NATURAL:
21158       case NEW:
21159       case NEW_DOT:
21160       case NO:
21161       case NONEDITIONABLE:
21162       case NOT:
21163       case NULL:
21164       case NULLIF:
21165       case OBJECT:
21166       case OID:
21167       case OPAQUE:
21168       case OPEN:
21169       case OPERATOR:
21170       case ORGANIZATION:
21171       case OTHERS:
21172       case OVERRIDING:
21173       case PACKAGE:
21174       case PARTITION:
21175       case PRESERVE:
21176       case PRIVATE:
21177       case PROCEDURE:
21178       case RANGE:
21179       case RAW:
21180       case REAL:
21181       case RECORD:
21182       case REF:
21183       case RELEASE:
21184       case RELIES_ON:
21185       case RENAME:
21186       case RESULT:
21187       case RETURN:
21188       case RETURNING:
21189       case REVERSE:
21190       case ROLLBACK:
21191       case ROW:
21192       case ROWS:
21193       case ROWID:
21194       case ROWNUM:
21195       case SAVE:
21196       case SAVEPOINT:
21197       case SECOND:
21198       case SELECT:
21199       case SELF:
21200       case SET:
21201       case SPACE:
21202       case SQL:
21203       case SQLCODE:
21204       case SQLERRM:
21205       case STATIC:
21206       case SUBTYPE:
21207       case SUBSTITUTABLE:
21208       case SUCCESSFUL:
21209       case SYSDATE:
21210       case SYS_REFCURSOR:
21211       case TEMPORARY:
21212       case TIME:
21213       case TIMESTAMP:
21214       case TIMEZONE_REGION:
21215       case TIMEZONE_ABBR:
21216       case TIMEZONE_MINUTE:
21217       case TIMEZONE_HOUR:
21218       case TRANSACTION:
21219       case TRUE:
21220       case TYPE:
21221       case UNDER:
21222       case USING:
21223       case YES:
21224       case SHOW:
21225       case A:
21226       case DOUBLE:
21227       case DEC:
21228       case PRECISION:
21229       case INT:
21230       case NUMERIC:
21231       case NCHAR:
21232       case NVARCHAR2:
21233       case STRING:
21234       case UROWID:
21235       case VARRAY:
21236       case VARYING:
21237       case BFILE:
21238       case BLOB:
21239       case CLOB:
21240       case NCLOB:
21241       case YEAR:
21242       case LOCAL:
21243       case WITH:
21244       case ZONE:
21245       case CHARACTER:
21246       case AFTER:
21247       case BEFORE:
21248       case OLD:
21249       case PARENT:
21250       case CC_IF:
21251       case ANALYZE:
21252       case ASSOCIATE:
21253       case AUDIT:
21254       case COMPOUND:
21255       case DATABASE:
21256       case CALL:
21257       case DDL:
21258       case DISASSOCIATE:
21259       case EACH:
21260       case FOLLOWS:
21261       case LOGOFF:
21262       case LOGON:
21263       case NESTED:
21264       case NOAUDIT:
21265       case SCHEMA:
21266       case SERVERERROR:
21267       case SHUTDOWN:
21268       case STARTUP:
21269       case STATEMENT:
21270       case STATISTICS:
21271       case SUSPEND:
21272       case TRUNCATE:
21273       case WRAPPED:
21274       case LIBRARY:
21275       case NAME:
21276       case STRUCT:
21277       case CONTEXT:
21278       case PARAMETERS:
21279       case LENGTH:
21280       case TDO:
21281       case MAXLEN:
21282       case CHARSETID:
21283       case CHARSETFORM:
21284       case ACCEPT:
21285       case ACCESSIBLE:
21286       case COPY:
21287       case DEFINE:
21288       case DISCONNECT:
21289       case HOST:
21290       case PRINT:
21291       case QUIT:
21292       case REMARK:
21293       case UNDEFINE:
21294       case VARIABLE:
21295       case WHENEVER:
21296       case ATTACH:
21297       case CAST:
21298       case TREAT:
21299       case TRIM:
21300       case LEFT:
21301       case RIGHT:
21302       case BOTH:
21303       case EMPTY:
21304       case MULTISET:
21305       case SUBMULTISET:
21306       case LEADING:
21307       case TRAILING:
21308       case CHAR_CS:
21309       case NCHAR_CS:
21310       case DBTIMEZONE:
21311       case SESSIONTIMEZONE:
21312       case AUTHENTICATED:
21313       case LINK:
21314       case SHARED:
21315       case DIRECTORY:
21316       case USER:
21317       case IDENTIFIER:
21318       case UNSIGNED_NUMERIC_LITERAL:
21319       case CHARACTER_LITERAL:
21320       case STRING_LITERAL:
21321       case QUOTED_LITERAL:
21322         ArgumentList();
21323         break;
21324       default:
21325         jj_la1[276] = jj_gen;
21326         ;
21327       }
21328       jj_consume_token(7);
21329    jjtree.closeNodeScope(jjtn000, true);
21330    jjtc000 = false;
21331  {if (true) return jjtn000 ;}
21332     } catch (Throwable jjte000) {
21333     if (jjtc000) {
21334       jjtree.clearNodeScope(jjtn000);
21335       jjtc000 = false;
21336     } else {
21337       jjtree.popNode();
21338     }
21339     if (jjte000 instanceof RuntimeException) {
21340       {if (true) throw (RuntimeException)jjte000;}
21341     }
21342     if (jjte000 instanceof ParseException) {
21343       {if (true) throw (ParseException)jjte000;}
21344     }
21345     {if (true) throw (Error)jjte000;}
21346     } finally {
21347     if (jjtc000) {
21348       jjtree.closeNodeScope(jjtn000, true);
21349     }
21350     }
21351     throw new Error("Missing return statement in function");
21352   }
21353 
21354   final public ASTArgumentList ArgumentList() throws ParseException {
21355  /*@bgen(jjtree) ArgumentList */
21356   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21357   boolean jjtc000 = true;
21358   jjtree.openNodeScope(jjtn000);
21359     try {
21360       Argument();
21361       label_66:
21362       while (true) {
21363         switch (jj_nt.kind) {
21364         case 6:
21365           ;
21366           break;
21367         default:
21368           jj_la1[277] = jj_gen;
21369           break label_66;
21370         }
21371         jj_consume_token(6);
21372         Argument();
21373       }
21374    jjtree.closeNodeScope(jjtn000, true);
21375    jjtc000 = false;
21376  {if (true) return jjtn000 ;}
21377     } catch (Throwable jjte000) {
21378     if (jjtc000) {
21379       jjtree.clearNodeScope(jjtn000);
21380       jjtc000 = false;
21381     } else {
21382       jjtree.popNode();
21383     }
21384     if (jjte000 instanceof RuntimeException) {
21385       {if (true) throw (RuntimeException)jjte000;}
21386     }
21387     if (jjte000 instanceof ParseException) {
21388       {if (true) throw (ParseException)jjte000;}
21389     }
21390     {if (true) throw (Error)jjte000;}
21391     } finally {
21392     if (jjtc000) {
21393       jjtree.closeNodeScope(jjtn000, true);
21394     }
21395     }
21396     throw new Error("Missing return statement in function");
21397   }
21398 
21399   final public ASTArgument Argument() throws ParseException {
21400  /*@bgen(jjtree) Argument */
21401  ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21402  boolean jjtc000 = true;
21403  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21404     try {
21405       if (jj_2_59(2)) {
21406         simpleNode = UnqualifiedID();
21407         switch (jj_nt.kind) {
21408         case 23:
21409           jj_consume_token(23);
21410           break;
21411         case AS:
21412           jj_consume_token(AS);
21413           break;
21414         default:
21415           jj_la1[278] = jj_gen;
21416           jj_consume_token(-1);
21417           throw new ParseException();
21418         }
21419       } else {
21420         ;
21421       }
21422       Expression();
21423       switch (jj_nt.kind) {
21424       case USING:
21425         jj_consume_token(USING);
21426         switch (jj_nt.kind) {
21427         case CHAR_CS:
21428           jj_consume_token(CHAR_CS);
21429           break;
21430         case NCHAR_CS:
21431           jj_consume_token(NCHAR_CS);
21432           break;
21433         default:
21434           jj_la1[279] = jj_gen;
21435           jj_consume_token(-1);
21436           throw new ParseException();
21437         }
21438         break;
21439       default:
21440         jj_la1[280] = jj_gen;
21441         ;
21442       }
21443    jjtree.closeNodeScope(jjtn000, true);
21444    jjtc000 = false;
21445  if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21446  {if (true) return jjtn000 ;}
21447     } catch (Throwable jjte000) {
21448           if (jjtc000) {
21449             jjtree.clearNodeScope(jjtn000);
21450             jjtc000 = false;
21451           } else {
21452             jjtree.popNode();
21453           }
21454           if (jjte000 instanceof RuntimeException) {
21455             {if (true) throw (RuntimeException)jjte000;}
21456           }
21457           if (jjte000 instanceof ParseException) {
21458             {if (true) throw (ParseException)jjte000;}
21459           }
21460           {if (true) throw (Error)jjte000;}
21461     } finally {
21462           if (jjtc000) {
21463             jjtree.closeNodeScope(jjtn000, true);
21464           }
21465     }
21466     throw new Error("Missing return statement in function");
21467   }
21468 
21469 // ============================================================================
21470 // D E C L A R A T I O N S
21471 // ============================================================================
21472   final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21473  /*@bgen(jjtree) VariableOrConstantDeclaration */
21474   ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21475   boolean jjtc000 = true;
21476   jjtree.openNodeScope(jjtn000);
21477     try {
21478       VariableOrConstantDeclarator();
21479       jj_consume_token(4);
21480     jjtree.closeNodeScope(jjtn000, true);
21481     jjtc000 = false;
21482     {if (true) return jjtn000 ;}
21483     } catch (Throwable jjte000) {
21484     if (jjtc000) {
21485       jjtree.clearNodeScope(jjtn000);
21486       jjtc000 = false;
21487     } else {
21488       jjtree.popNode();
21489     }
21490     if (jjte000 instanceof RuntimeException) {
21491       {if (true) throw (RuntimeException)jjte000;}
21492     }
21493     if (jjte000 instanceof ParseException) {
21494       {if (true) throw (ParseException)jjte000;}
21495     }
21496     {if (true) throw (Error)jjte000;}
21497     } finally {
21498     if (jjtc000) {
21499       jjtree.closeNodeScope(jjtn000, true);
21500     }
21501     }
21502     throw new Error("Missing return statement in function");
21503   }
21504 
21505   final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21506  /*@bgen(jjtree) DatatypeDeclaration */
21507  ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21508  boolean jjtc000 = true;
21509  jjtree.openNodeScope(jjtn000);Token t ;
21510     try {
21511       t = jj_consume_token(IDENTIFIER);
21512     jjtree.closeNodeScope(jjtn000, true);
21513     jjtc000 = false;
21514     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
21515     } finally {
21516     if (jjtc000) {
21517       jjtree.closeNodeScope(jjtn000, true);
21518     }
21519     }
21520     throw new Error("Missing return statement in function");
21521   }
21522 
21523   final public ASTPragma Pragma() throws ParseException {
21524  /*@bgen(jjtree) Pragma */
21525   ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21526   boolean jjtc000 = true;
21527   jjtree.openNodeScope(jjtn000);
21528     try {
21529       jj_consume_token(PRAGMA);
21530       switch (jj_nt.kind) {
21531       case SERIALLY_REUSABLE:
21532         jj_consume_token(SERIALLY_REUSABLE);
21533         break;
21534       case AUTONOMOUS_TRANSACTION:
21535         jj_consume_token(AUTONOMOUS_TRANSACTION);
21536         break;
21537       case TIMESTAMP:
21538         jj_consume_token(TIMESTAMP);
21539         jj_consume_token(5);
21540         StringLiteral();
21541         jj_consume_token(7);
21542         break;
21543       case RESTRICT_REFERENCES:
21544         jj_consume_token(RESTRICT_REFERENCES);
21545         jj_consume_token(5);
21546         ID();
21547         label_67:
21548         while (true) {
21549           jj_consume_token(6);
21550           switch (jj_nt.kind) {
21551           case REPLACE:
21552           case DEFINER:
21553           case CURRENT_USER:
21554           case SERIALLY_REUSABLE:
21555           case RESTRICT_REFERENCES:
21556           case EXCEPTION_INIT:
21557           case AUTONOMOUS_TRANSACTION:
21558           case LANGUAGE:
21559           case INLINE:
21560           case ADD:
21561           case AGGREGATE:
21562           case ALL:
21563           case ALTER:
21564           case AND:
21565           case ANY:
21566           case ARRAY:
21567           case AS:
21568           case ASC:
21569           case AT:
21570           case ATTRIBUTE:
21571           case AUTHID:
21572           case AVG:
21573           case BETWEEN:
21574           case BINARY_INTEGER:
21575           case BODY:
21576           case BOOLEAN:
21577           case BULK:
21578           case BY:
21579           case BYTE:
21580           case CASCADE:
21581           case CASE:
21582           case CHAR:
21583           case CHAR_BASE:
21584           case CHECK:
21585           case CLOSE:
21586           case CLUSTER:
21587           case COALESCE:
21588           case COLLECT:
21589           case COLUMN:
21590           case COMMENT:
21591           case COMMIT:
21592           case COMPRESS:
21593           case CONNECT:
21594           case CONSTANT:
21595           case CONSTRUCTOR:
21596           case CONTINUE:
21597           case CONVERT:
21598           case CREATE:
21599           case CURRENT:
21600           case CURRVAL:
21601           case CURSOR:
21602           case DATA:
21603           case DATE:
21604           case DAY:
21605           case DECLARE:
21606           case DECIMAL:
21607           case _DEFAULT:
21608           case DELETE:
21609           case DESC:
21610           case DISABLE:
21611           case DISTINCT:
21612           case DO:
21613           case DROP:
21614           case EDITIONABLE:
21615           case ELEMENT:
21616           case ELSE:
21617           case ELSIF:
21618           case ENABLE:
21619           case ESCAPE:
21620           case EXCEPT:
21621           case EXCEPTION:
21622           case EXCEPTIONS:
21623           case EXCLUSIVE:
21624           case EXECUTE:
21625           case EXISTS:
21626           case EXIT:
21627           case EXTERNAL:
21628           case EXTENDS:
21629           case EXTRACT:
21630           case FALSE:
21631           case FETCH:
21632           case FINAL:
21633           case FLOAT:
21634           case FOR:
21635           case FORALL:
21636           case FORCE:
21637           case FROM:
21638           case FUNCTION:
21639           case GLOBAL:
21640           case GOTO:
21641           case GROUP:
21642           case HASH:
21643           case HAVING:
21644           case HEAP:
21645           case HOUR:
21646           case IF:
21647           case IMMEDIATE:
21648           case IN:
21649           case INDEX:
21650           case INDICES:
21651           case INDEXTYPE:
21652           case INDICATOR:
21653           case INSERT:
21654           case INSTANTIABLE:
21655           case INTEGER:
21656           case INTERFACE:
21657           case INTERSECT:
21658           case INTERVAL:
21659           case INTO:
21660           case INVALIDATE:
21661           case IS:
21662           case ISOLATION:
21663           case JAVA:
21664           case LEVEL:
21665           case LIKE:
21666           case LIMIT:
21667           case LIMITED:
21668           case LOCK:
21669           case LONG:
21670           case LOOP:
21671           case MAP:
21672           case MAX:
21673           case MEMBER:
21674           case MERGE:
21675           case MIN:
21676           case MINUS:
21677           case MINUTE:
21678           case MLSLABEL:
21679           case MODIFY:
21680           case MOD:
21681           case MODE:
21682           case MONTH:
21683           case NATURAL:
21684           case NATURALN:
21685           case NEW:
21686           case NEXTVAL:
21687           case NO:
21688           case NOCOPY:
21689           case NONEDITIONABLE:
21690           case NOT:
21691           case NOWAIT:
21692           case NULL:
21693           case NULLIF:
21694           case NUMBER:
21695           case BFILE_BASE:
21696           case BLOB_BASE:
21697           case CLOB_BASE:
21698           case DATE_BASE:
21699           case NUMBER_BASE:
21700           case OBJECT:
21701           case OCIROWID:
21702           case OF:
21703           case OID:
21704           case ON:
21705           case OPAQUE:
21706           case OPEN:
21707           case OPERATOR:
21708           case OPTION:
21709           case OR:
21710           case ORDER:
21711           case ORGANIZATION:
21712           case OTHERS:
21713           case OUT:
21714           case OVERRIDING:
21715           case PACKAGE:
21716           case PARTITION:
21717           case PCTFREE:
21718           case PLS_INTEGER:
21719           case POSITIVE:
21720           case POSITIVEN:
21721           case PRESERVE:
21722           case PRIOR:
21723           case PROMPT:
21724           case PRIVATE:
21725           case PROCEDURE:
21726           case PUBLIC:
21727           case RAISE:
21728           case RANGE:
21729           case RAW:
21730           case REAL:
21731           case RECORD:
21732           case REF:
21733           case RELEASE:
21734           case RELIES_ON:
21735           case RENAME:
21736           case RESULT:
21737           case RETURN:
21738           case RETURNING:
21739           case REVERSE:
21740           case ROLLBACK:
21741           case ROW:
21742           case ROWS:
21743           case ROWID:
21744           case ROWNUM:
21745           case ROWTYPE:
21746           case SAVE:
21747           case SAVEPOINT:
21748           case SECOND:
21749           case SELECT:
21750           case SELF:
21751           case SEPARATE:
21752           case SET:
21753           case SHARE:
21754           case SMALLINT:
21755           case SPACE:
21756           case SQL:
21757           case SQLCODE:
21758           case SQLERRM:
21759           case START:
21760           case STATIC:
21761           case STDDEV:
21762           case SUBTYPE:
21763           case SUBSTITUTABLE:
21764           case SUCCESSFUL:
21765           case SUM:
21766           case SYNONYM:
21767           case SYSDATE:
21768           case SYS_REFCURSOR:
21769           case TABLE:
21770           case TEMPORARY:
21771           case THEN:
21772           case TIME:
21773           case TIMESTAMP:
21774           case TIMEZONE_REGION:
21775           case TIMEZONE_ABBR:
21776           case TIMEZONE_MINUTE:
21777           case TIMEZONE_HOUR:
21778           case TO:
21779           case TRANSACTION:
21780           case TRIGGER:
21781           case TRUE:
21782           case TYPE:
21783           case UI:
21784           case UNDER:
21785           case USING:
21786           case WHILE:
21787           case YES:
21788           case SHOW:
21789           case A:
21790           case UPDATE:
21791           case VARCHAR:
21792           case VARCHAR2:
21793           case DOUBLE:
21794           case DEC:
21795           case PRECISION:
21796           case INT:
21797           case NUMERIC:
21798           case SIGNTYPE:
21799           case NCHAR:
21800           case NVARCHAR2:
21801           case STRING:
21802           case UROWID:
21803           case VARRAY:
21804           case VARYING:
21805           case BFILE:
21806           case BLOB:
21807           case CLOB:
21808           case NCLOB:
21809           case YEAR:
21810           case LOCAL:
21811           case WITH:
21812           case ZONE:
21813           case CHARACTER:
21814           case AFTER:
21815           case BEFORE:
21816           case OLD:
21817           case PARENT:
21818           case ANALYZE:
21819           case ASSOCIATE:
21820           case AUDIT:
21821           case COMPOUND:
21822           case DATABASE:
21823           case CALL:
21824           case DDL:
21825           case DISASSOCIATE:
21826           case EACH:
21827           case FOLLOWS:
21828           case LOGOFF:
21829           case LOGON:
21830           case NESTED:
21831           case NOAUDIT:
21832           case SCHEMA:
21833           case SERVERERROR:
21834           case SHUTDOWN:
21835           case STARTUP:
21836           case STATEMENT:
21837           case STATISTICS:
21838           case SUSPEND:
21839           case TRUNCATE:
21840           case WRAPPED:
21841           case LIBRARY:
21842           case NAME:
21843           case STRUCT:
21844           case CONTEXT:
21845           case PARAMETERS:
21846           case LENGTH:
21847           case TDO:
21848           case MAXLEN:
21849           case CHARSETID:
21850           case CHARSETFORM:
21851           case ACCEPT:
21852           case ACCESSIBLE:
21853           case COPY:
21854           case DEFINE:
21855           case DISCONNECT:
21856           case HOST:
21857           case PRINT:
21858           case QUIT:
21859           case REMARK:
21860           case UNDEFINE:
21861           case VARIABLE:
21862           case WHENEVER:
21863           case ATTACH:
21864           case CAST:
21865           case TREAT:
21866           case TRIM:
21867           case LEFT:
21868           case RIGHT:
21869           case BOTH:
21870           case EMPTY:
21871           case MULTISET:
21872           case SUBMULTISET:
21873           case LEADING:
21874           case TRAILING:
21875           case CHAR_CS:
21876           case NCHAR_CS:
21877           case DBTIMEZONE:
21878           case SESSIONTIMEZONE:
21879           case AUTHENTICATED:
21880           case LINK:
21881           case SHARED:
21882           case DIRECTORY:
21883           case USER:
21884           case IDENTIFIER:
21885           case QUOTED_LITERAL:
21886           case SQLDATA_CLASS:
21887           case CUSTOMDATUM_CLASS:
21888           case ORADATA_CLASS:
21889           case JAVA_INTERFACE_CLASS:
21890             ID();
21891             break;
21892           case STRING_LITERAL:
21893             StringLiteral();
21894             break;
21895           default:
21896             jj_la1[281] = jj_gen;
21897             jj_consume_token(-1);
21898             throw new ParseException();
21899           }
21900           switch (jj_nt.kind) {
21901           case 6:
21902             ;
21903             break;
21904           default:
21905             jj_la1[282] = jj_gen;
21906             break label_67;
21907           }
21908         }
21909         jj_consume_token(7);
21910         break;
21911       case EXCEPTION_INIT:
21912         jj_consume_token(EXCEPTION_INIT);
21913         jj_consume_token(5);
21914         jj_consume_token(IDENTIFIER);
21915         jj_consume_token(6);
21916         switch (jj_nt.kind) {
21917         case 16:
21918         case 17:
21919           switch (jj_nt.kind) {
21920           case 16:
21921             jj_consume_token(16);
21922             break;
21923           case 17:
21924             jj_consume_token(17);
21925             break;
21926           default:
21927             jj_la1[283] = jj_gen;
21928             jj_consume_token(-1);
21929             throw new ParseException();
21930           }
21931           break;
21932         default:
21933           jj_la1[284] = jj_gen;
21934           ;
21935         }
21936         NumericLiteral();
21937         jj_consume_token(7);
21938         break;
21939       case INTERFACE:
21940         jj_consume_token(INTERFACE);
21941         jj_consume_token(5);
21942         jj_consume_token(IDENTIFIER);
21943         jj_consume_token(6);
21944         ID();
21945         switch (jj_nt.kind) {
21946         case 6:
21947           jj_consume_token(6);
21948           NumericLiteral();
21949           break;
21950         default:
21951           jj_la1[285] = jj_gen;
21952           ;
21953         }
21954         jj_consume_token(7);
21955         break;
21956       case REPLACE:
21957       case DEFINER:
21958       case CURRENT_USER:
21959       case LANGUAGE:
21960       case INLINE:
21961       case ADD:
21962       case AGGREGATE:
21963       case ARRAY:
21964       case AT:
21965       case ATTRIBUTE:
21966       case AUTHID:
21967       case BODY:
21968       case BULK:
21969       case BYTE:
21970       case CASCADE:
21971       case CLOSE:
21972       case COALESCE:
21973       case COLLECT:
21974       case COLUMN:
21975       case COMMENT:
21976       case COMMIT:
21977       case CONSTRUCTOR:
21978       case CONTINUE:
21979       case CONVERT:
21980       case CURRENT:
21981       case CURSOR:
21982       case DATA:
21983       case DAY:
21984       case DISABLE:
21985       case EDITIONABLE:
21986       case ELEMENT:
21987       case ENABLE:
21988       case ESCAPE:
21989       case EXCEPT:
21990       case EXCEPTIONS:
21991       case EXIT:
21992       case EXTERNAL:
21993       case EXTENDS:
21994       case EXTRACT:
21995       case FALSE:
21996       case FINAL:
21997       case FORCE:
21998       case FUNCTION:
21999       case GLOBAL:
22000       case HASH:
22001       case HEAP:
22002       case HOUR:
22003       case IMMEDIATE:
22004       case INDICES:
22005       case INDEXTYPE:
22006       case INDICATOR:
22007       case INSTANTIABLE:
22008       case INTERVAL:
22009       case INVALIDATE:
22010       case ISOLATION:
22011       case JAVA:
22012       case LEVEL:
22013       case LIMIT:
22014       case LOOP:
22015       case MAP:
22016       case MAX:
22017       case MEMBER:
22018       case MERGE:
22019       case MIN:
22020       case MINUTE:
22021       case MLSLABEL:
22022       case MODIFY:
22023       case MOD:
22024       case MONTH:
22025       case NATURAL:
22026       case NEW:
22027       case NO:
22028       case NONEDITIONABLE:
22029       case NULLIF:
22030       case OBJECT:
22031       case OID:
22032       case OPAQUE:
22033       case OPEN:
22034       case OPERATOR:
22035       case ORGANIZATION:
22036       case OTHERS:
22037       case OVERRIDING:
22038       case PACKAGE:
22039       case PARTITION:
22040       case PRESERVE:
22041       case PRIVATE:
22042       case PROCEDURE:
22043       case RANGE:
22044       case RAW:
22045       case REAL:
22046       case RECORD:
22047       case REF:
22048       case RELEASE:
22049       case RELIES_ON:
22050       case RENAME:
22051       case RESULT:
22052       case RETURN:
22053       case RETURNING:
22054       case REVERSE:
22055       case ROLLBACK:
22056       case ROW:
22057       case ROWS:
22058       case ROWID:
22059       case ROWNUM:
22060       case SAVE:
22061       case SAVEPOINT:
22062       case SECOND:
22063       case SELF:
22064       case SET:
22065       case SPACE:
22066       case SQL:
22067       case SQLCODE:
22068       case SQLERRM:
22069       case STATIC:
22070       case SUBTYPE:
22071       case SUBSTITUTABLE:
22072       case SUCCESSFUL:
22073       case SYSDATE:
22074       case SYS_REFCURSOR:
22075       case TEMPORARY:
22076       case TIME:
22077       case TIMEZONE_REGION:
22078       case TIMEZONE_ABBR:
22079       case TIMEZONE_MINUTE:
22080       case TIMEZONE_HOUR:
22081       case TRANSACTION:
22082       case TRUE:
22083       case TYPE:
22084       case UNDER:
22085       case USING:
22086       case YES:
22087       case SHOW:
22088       case A:
22089       case DOUBLE:
22090       case DEC:
22091       case PRECISION:
22092       case INT:
22093       case NUMERIC:
22094       case NCHAR:
22095       case NVARCHAR2:
22096       case STRING:
22097       case UROWID:
22098       case VARRAY:
22099       case VARYING:
22100       case BFILE:
22101       case BLOB:
22102       case CLOB:
22103       case NCLOB:
22104       case YEAR:
22105       case LOCAL:
22106       case ZONE:
22107       case CHARACTER:
22108       case AFTER:
22109       case BEFORE:
22110       case OLD:
22111       case PARENT:
22112       case ANALYZE:
22113       case ASSOCIATE:
22114       case AUDIT:
22115       case COMPOUND:
22116       case DATABASE:
22117       case CALL:
22118       case DDL:
22119       case DISASSOCIATE:
22120       case EACH:
22121       case FOLLOWS:
22122       case LOGOFF:
22123       case LOGON:
22124       case NESTED:
22125       case NOAUDIT:
22126       case SCHEMA:
22127       case SERVERERROR:
22128       case SHUTDOWN:
22129       case STARTUP:
22130       case STATEMENT:
22131       case STATISTICS:
22132       case SUSPEND:
22133       case TRUNCATE:
22134       case WRAPPED:
22135       case LIBRARY:
22136       case NAME:
22137       case STRUCT:
22138       case CONTEXT:
22139       case PARAMETERS:
22140       case LENGTH:
22141       case TDO:
22142       case MAXLEN:
22143       case CHARSETID:
22144       case CHARSETFORM:
22145       case ACCEPT:
22146       case ACCESSIBLE:
22147       case COPY:
22148       case DEFINE:
22149       case DISCONNECT:
22150       case HOST:
22151       case PRINT:
22152       case QUIT:
22153       case REMARK:
22154       case UNDEFINE:
22155       case VARIABLE:
22156       case WHENEVER:
22157       case ATTACH:
22158       case CAST:
22159       case TREAT:
22160       case TRIM:
22161       case LEFT:
22162       case RIGHT:
22163       case BOTH:
22164       case EMPTY:
22165       case MULTISET:
22166       case SUBMULTISET:
22167       case LEADING:
22168       case TRAILING:
22169       case CHAR_CS:
22170       case NCHAR_CS:
22171       case DBTIMEZONE:
22172       case SESSIONTIMEZONE:
22173       case AUTHENTICATED:
22174       case LINK:
22175       case SHARED:
22176       case DIRECTORY:
22177       case USER:
22178       case IDENTIFIER:
22179       case QUOTED_LITERAL:
22180         QualifiedName();
22181         jj_consume_token(5);
22182         ReadPastNextOccurrence(")");
22183         break;
22184       default:
22185         jj_la1[286] = jj_gen;
22186         jj_consume_token(-1);
22187         throw new ParseException();
22188       }
22189       jj_consume_token(4);
22190         jjtree.closeNodeScope(jjtn000, true);
22191         jjtc000 = false;
22192         {if (true) return jjtn000 ;}
22193     } catch (Throwable jjte000) {
22194           if (jjtc000) {
22195             jjtree.clearNodeScope(jjtn000);
22196             jjtc000 = false;
22197           } else {
22198             jjtree.popNode();
22199           }
22200           if (jjte000 instanceof RuntimeException) {
22201             {if (true) throw (RuntimeException)jjte000;}
22202           }
22203           if (jjte000 instanceof ParseException) {
22204             {if (true) throw (ParseException)jjte000;}
22205           }
22206           {if (true) throw (Error)jjte000;}
22207     } finally {
22208           if (jjtc000) {
22209             jjtree.closeNodeScope(jjtn000, true);
22210           }
22211     }
22212     throw new Error("Missing return statement in function");
22213   }
22214 
22215   final public ASTInlinePragma InlinePragma() throws ParseException {
22216  /*@bgen(jjtree) InlinePragma */
22217   ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
22218   boolean jjtc000 = true;
22219   jjtree.openNodeScope(jjtn000);
22220     try {
22221       jj_consume_token(PRAGMA);
22222       jj_consume_token(INLINE);
22223       jj_consume_token(5);
22224       QualifiedName();
22225       jj_consume_token(6);
22226       StringLiteral();
22227       jj_consume_token(7);
22228         jjtree.closeNodeScope(jjtn000, true);
22229         jjtc000 = false;
22230         {if (true) return jjtn000 ;}
22231     } catch (Throwable jjte000) {
22232           if (jjtc000) {
22233             jjtree.clearNodeScope(jjtn000);
22234             jjtc000 = false;
22235           } else {
22236             jjtree.popNode();
22237           }
22238           if (jjte000 instanceof RuntimeException) {
22239             {if (true) throw (RuntimeException)jjte000;}
22240           }
22241           if (jjte000 instanceof ParseException) {
22242             {if (true) throw (ParseException)jjte000;}
22243           }
22244           {if (true) throw (Error)jjte000;}
22245     } finally {
22246           if (jjtc000) {
22247             jjtree.closeNodeScope(jjtn000, true);
22248           }
22249     }
22250     throw new Error("Missing return statement in function");
22251   }
22252 
22253   final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
22254  /*@bgen(jjtree) ExceptionDeclaration */
22255  ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
22256  boolean jjtc000 = true;
22257  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22258     try {
22259       simpleNode = ID();
22260       jj_consume_token(EXCEPTION);
22261       jj_consume_token(4);
22262         jjtree.closeNodeScope(jjtn000, true);
22263         jjtc000 = false;
22264         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22265     } catch (Throwable jjte000) {
22266           if (jjtc000) {
22267             jjtree.clearNodeScope(jjtn000);
22268             jjtc000 = false;
22269           } else {
22270             jjtree.popNode();
22271           }
22272           if (jjte000 instanceof RuntimeException) {
22273             {if (true) throw (RuntimeException)jjte000;}
22274           }
22275           if (jjte000 instanceof ParseException) {
22276             {if (true) throw (ParseException)jjte000;}
22277           }
22278           {if (true) throw (Error)jjte000;}
22279     } finally {
22280           if (jjtc000) {
22281             jjtree.closeNodeScope(jjtn000, true);
22282           }
22283     }
22284     throw new Error("Missing return statement in function");
22285   }
22286 
22287   final public ASTParallelClause ParallelClause() throws ParseException {
22288  /*@bgen(jjtree) ParallelClause */
22289   ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
22290   boolean jjtc000 = true;
22291   jjtree.openNodeScope(jjtn000);
22292     try {
22293       jj_consume_token(5);
22294       jj_consume_token(PARTITION);
22295       ID();
22296       jj_consume_token(BY);
22297       switch (jj_nt.kind) {
22298       case ANY:
22299         jj_consume_token(ANY);
22300         break;
22301       case HASH:
22302       case RANGE:
22303         switch (jj_nt.kind) {
22304         case HASH:
22305           jj_consume_token(HASH);
22306           break;
22307         case RANGE:
22308           jj_consume_token(RANGE);
22309           break;
22310         default:
22311           jj_la1[287] = jj_gen;
22312           jj_consume_token(-1);
22313           throw new ParseException();
22314         }
22315         jj_consume_token(5);
22316         ID();
22317         label_68:
22318         while (true) {
22319           switch (jj_nt.kind) {
22320           case 6:
22321             ;
22322             break;
22323           default:
22324             jj_la1[288] = jj_gen;
22325             break label_68;
22326           }
22327           jj_consume_token(6);
22328           ID();
22329         }
22330         jj_consume_token(7);
22331         break;
22332       default:
22333         jj_la1[289] = jj_gen;
22334         jj_consume_token(-1);
22335         throw new ParseException();
22336       }
22337       jj_consume_token(7);
22338       switch (jj_nt.kind) {
22339       case CLUSTER:
22340       case ORDER:
22341         switch (jj_nt.kind) {
22342         case ORDER:
22343           jj_consume_token(ORDER);
22344           break;
22345         case CLUSTER:
22346           jj_consume_token(CLUSTER);
22347           break;
22348         default:
22349           jj_la1[290] = jj_gen;
22350           jj_consume_token(-1);
22351           throw new ParseException();
22352         }
22353         jj_consume_token(BY);
22354         jj_consume_token(5);
22355         ID();
22356         label_69:
22357         while (true) {
22358           switch (jj_nt.kind) {
22359           case 6:
22360             ;
22361             break;
22362           default:
22363             jj_la1[291] = jj_gen;
22364             break label_69;
22365           }
22366           jj_consume_token(6);
22367           ID();
22368         }
22369         jj_consume_token(7);
22370         break;
22371       default:
22372         jj_la1[292] = jj_gen;
22373         ;
22374       }
22375         jjtree.closeNodeScope(jjtn000, true);
22376         jjtc000 = false;
22377         {if (true) return jjtn000 ;}
22378     } catch (Throwable jjte000) {
22379       if (jjtc000) {
22380         jjtree.clearNodeScope(jjtn000);
22381         jjtc000 = false;
22382       } else {
22383         jjtree.popNode();
22384       }
22385       if (jjte000 instanceof RuntimeException) {
22386         {if (true) throw (RuntimeException)jjte000;}
22387       }
22388       if (jjte000 instanceof ParseException) {
22389         {if (true) throw (ParseException)jjte000;}
22390       }
22391       {if (true) throw (Error)jjte000;}
22392     } finally {
22393       if (jjtc000) {
22394         jjtree.closeNodeScope(jjtn000, true);
22395       }
22396     }
22397     throw new Error("Missing return statement in function");
22398   }
22399 
22400   final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22401  /*@bgen(jjtree) AccessibleByClause */
22402   ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22403   boolean jjtc000 = true;
22404   jjtree.openNodeScope(jjtn000);
22405     try {
22406       jj_consume_token(ACCESSIBLE);
22407       jj_consume_token(BY);
22408       jj_consume_token(5);
22409       switch (jj_nt.kind) {
22410       case FUNCTION:
22411       case PACKAGE:
22412       case PROCEDURE:
22413       case TRIGGER:
22414       case TYPE:
22415         switch (jj_nt.kind) {
22416         case FUNCTION:
22417           jj_consume_token(FUNCTION);
22418           break;
22419         case PROCEDURE:
22420           jj_consume_token(PROCEDURE);
22421           break;
22422         case PACKAGE:
22423           jj_consume_token(PACKAGE);
22424           break;
22425         case TRIGGER:
22426           jj_consume_token(TRIGGER);
22427           break;
22428         case TYPE:
22429           jj_consume_token(TYPE);
22430           break;
22431         default:
22432           jj_la1[293] = jj_gen;
22433           jj_consume_token(-1);
22434           throw new ParseException();
22435         }
22436         break;
22437       default:
22438         jj_la1[294] = jj_gen;
22439         ;
22440       }
22441       QualifiedName();
22442       label_70:
22443       while (true) {
22444         switch (jj_nt.kind) {
22445         case 6:
22446           ;
22447           break;
22448         default:
22449           jj_la1[295] = jj_gen;
22450           break label_70;
22451         }
22452         jj_consume_token(6);
22453         switch (jj_nt.kind) {
22454         case FUNCTION:
22455         case PACKAGE:
22456         case PROCEDURE:
22457         case TRIGGER:
22458         case TYPE:
22459           switch (jj_nt.kind) {
22460           case FUNCTION:
22461             jj_consume_token(FUNCTION);
22462             break;
22463           case PROCEDURE:
22464             jj_consume_token(PROCEDURE);
22465             break;
22466           case PACKAGE:
22467             jj_consume_token(PACKAGE);
22468             break;
22469           case TRIGGER:
22470             jj_consume_token(TRIGGER);
22471             break;
22472           case TYPE:
22473             jj_consume_token(TYPE);
22474             break;
22475           default:
22476             jj_la1[296] = jj_gen;
22477             jj_consume_token(-1);
22478             throw new ParseException();
22479           }
22480           break;
22481         default:
22482           jj_la1[297] = jj_gen;
22483           ;
22484         }
22485         QualifiedName();
22486       }
22487       jj_consume_token(7);
22488         jjtree.closeNodeScope(jjtn000, true);
22489         jjtc000 = false;
22490         {if (true) return jjtn000 ;}
22491     } catch (Throwable jjte000) {
22492       if (jjtc000) {
22493         jjtree.clearNodeScope(jjtn000);
22494         jjtc000 = false;
22495       } else {
22496         jjtree.popNode();
22497       }
22498       if (jjte000 instanceof RuntimeException) {
22499         {if (true) throw (RuntimeException)jjte000;}
22500       }
22501       if (jjte000 instanceof ParseException) {
22502         {if (true) throw (ParseException)jjte000;}
22503       }
22504       {if (true) throw (Error)jjte000;}
22505     } finally {
22506       if (jjtc000) {
22507         jjtree.closeNodeScope(jjtn000, true);
22508       }
22509     }
22510     throw new Error("Missing return statement in function");
22511   }
22512 
22513 // Copyright (C) 2002 Albert Tumanov
22514 
22515 /**
22516  * 2006-05-10 - Matthias Hendler - merged SIV and sourceforge sources
22517  */
22518 
22519 // SRT *
22520   final public ASTTable Table() throws ParseException {
22521  /*@bgen(jjtree) Table */
22522   ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22523   boolean jjtc000 = true;
22524   jjtree.openNodeScope(jjtn000);
22525     try {
22526       jj_consume_token(CREATE);
22527       switch (jj_nt.kind) {
22528       case GLOBAL:
22529         jj_consume_token(GLOBAL);
22530         jj_consume_token(TEMPORARY);
22531         break;
22532       default:
22533         jj_la1[298] = jj_gen;
22534         ;
22535       }
22536       jj_consume_token(TABLE);
22537       ObjectNameDeclaration();
22538       jj_consume_token(5);
22539       TableColumn();
22540       label_71:
22541       while (true) {
22542         switch (jj_nt.kind) {
22543         case 6:
22544           ;
22545           break;
22546         default:
22547           jj_la1[299] = jj_gen;
22548           break label_71;
22549         }
22550         jj_consume_token(6);
22551         TableColumn();
22552       }
22553       jj_consume_token(7);
22554       if (jj_2_60(2)) {
22555         jj_consume_token(ON);
22556         jj_consume_token(COMMIT);
22557         switch (jj_nt.kind) {
22558         case DELETE:
22559           jj_consume_token(DELETE);
22560           break;
22561         case PRESERVE:
22562           jj_consume_token(PRESERVE);
22563           break;
22564         default:
22565           jj_la1[300] = jj_gen;
22566           jj_consume_token(-1);
22567           throw new ParseException();
22568         }
22569         jj_consume_token(ROWS);
22570       } else {
22571         ;
22572       }
22573       switch (jj_nt.kind) {
22574       case 4:
22575         jj_consume_token(4);
22576         break;
22577       default:
22578         jj_la1[301] = jj_gen;
22579         ;
22580       }
22581         jjtree.closeNodeScope(jjtn000, true);
22582         jjtc000 = false;
22583         {if (true) return jjtn000 ;}
22584     } catch (Throwable jjte000) {
22585     if (jjtc000) {
22586       jjtree.clearNodeScope(jjtn000);
22587       jjtc000 = false;
22588     } else {
22589       jjtree.popNode();
22590     }
22591     if (jjte000 instanceof RuntimeException) {
22592       {if (true) throw (RuntimeException)jjte000;}
22593     }
22594     if (jjte000 instanceof ParseException) {
22595       {if (true) throw (ParseException)jjte000;}
22596     }
22597     {if (true) throw (Error)jjte000;}
22598     } finally {
22599     if (jjtc000) {
22600       jjtree.closeNodeScope(jjtn000, true);
22601     }
22602     }
22603     throw new Error("Missing return statement in function");
22604   }
22605 
22606   final public ASTTableColumn TableColumn() throws ParseException {
22607  /*@bgen(jjtree) TableColumn */
22608   ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22609   boolean jjtc000 = true;
22610   jjtree.openNodeScope(jjtn000);
22611     try {
22612       ID();
22613       Datatype();
22614       switch (jj_nt.kind) {
22615       case _DEFAULT:
22616         jj_consume_token(_DEFAULT);
22617         Expression();
22618         break;
22619       default:
22620         jj_la1[302] = jj_gen;
22621         ;
22622       }
22623       switch (jj_nt.kind) {
22624       case NOT:
22625       case NULL:
22626         switch (jj_nt.kind) {
22627         case NOT:
22628           jj_consume_token(NOT);
22629           break;
22630         default:
22631           jj_la1[303] = jj_gen;
22632           ;
22633         }
22634         jj_consume_token(NULL);
22635         break;
22636       default:
22637         jj_la1[304] = jj_gen;
22638         ;
22639       }
22640         jjtree.closeNodeScope(jjtn000, true);
22641         jjtc000 = false;
22642         {if (true) return jjtn000 ;}
22643     } catch (Throwable jjte000) {
22644     if (jjtc000) {
22645       jjtree.clearNodeScope(jjtn000);
22646       jjtc000 = false;
22647     } else {
22648       jjtree.popNode();
22649     }
22650     if (jjte000 instanceof RuntimeException) {
22651       {if (true) throw (RuntimeException)jjte000;}
22652     }
22653     if (jjte000 instanceof ParseException) {
22654       {if (true) throw (ParseException)jjte000;}
22655     }
22656     {if (true) throw (Error)jjte000;}
22657     } finally {
22658     if (jjtc000) {
22659       jjtree.closeNodeScope(jjtn000, true);
22660     }
22661     }
22662     throw new Error("Missing return statement in function");
22663   }
22664 
22665   final public ASTView View() throws ParseException {
22666  /*@bgen(jjtree) View */
22667  ASTView jjtn000 = new ASTView(this, JJTVIEW);
22668  boolean jjtc000 = true;
22669  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22670     try {
22671       jj_consume_token(CREATE);
22672       switch (jj_nt.kind) {
22673       case OR:
22674         jj_consume_token(OR);
22675         jj_consume_token(REPLACE);
22676         break;
22677       default:
22678         jj_la1[305] = jj_gen;
22679         ;
22680       }
22681       switch (jj_nt.kind) {
22682       case FORCE:
22683       case NO:
22684         switch (jj_nt.kind) {
22685         case NO:
22686           jj_consume_token(NO);
22687           break;
22688         default:
22689           jj_la1[306] = jj_gen;
22690           ;
22691         }
22692         jj_consume_token(FORCE);
22693         break;
22694       default:
22695         jj_la1[307] = jj_gen;
22696         ;
22697       }
22698       jj_consume_token(VIEW);
22699       simpleNode = ObjectNameDeclaration();
22700       switch (jj_nt.kind) {
22701       case 5:
22702         jj_consume_token(5);
22703         ViewColumn();
22704         label_72:
22705         while (true) {
22706           switch (jj_nt.kind) {
22707           case 6:
22708             ;
22709             break;
22710           default:
22711             jj_la1[308] = jj_gen;
22712             break label_72;
22713           }
22714           jj_consume_token(6);
22715           ViewColumn();
22716         }
22717         jj_consume_token(7);
22718         break;
22719       default:
22720         jj_la1[309] = jj_gen;
22721         ;
22722       }
22723       jj_consume_token(AS);
22724       Statement();
22725       switch (jj_nt.kind) {
22726       case 4:
22727         jj_consume_token(4);
22728         break;
22729       case 1:
22730         jj_consume_token(1);
22731         break;
22732       default:
22733         jj_la1[310] = jj_gen;
22734         jj_consume_token(-1);
22735         throw new ParseException();
22736       }
22737     jjtree.closeNodeScope(jjtn000, true);
22738     jjtc000 = false;
22739     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22740     } catch (Throwable jjte000) {
22741     if (jjtc000) {
22742       jjtree.clearNodeScope(jjtn000);
22743       jjtc000 = false;
22744     } else {
22745       jjtree.popNode();
22746     }
22747     if (jjte000 instanceof RuntimeException) {
22748       {if (true) throw (RuntimeException)jjte000;}
22749     }
22750     if (jjte000 instanceof ParseException) {
22751       {if (true) throw (ParseException)jjte000;}
22752     }
22753     {if (true) throw (Error)jjte000;}
22754     } finally {
22755     if (jjtc000) {
22756       jjtree.closeNodeScope(jjtn000, true);
22757     }
22758     }
22759     throw new Error("Missing return statement in function");
22760   }
22761 
22762   final public ASTSynonym Synonym() throws ParseException {
22763  /*@bgen(jjtree) Synonym */
22764  ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22765  boolean jjtc000 = true;
22766  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22767     try {
22768       jj_consume_token(CREATE);
22769       switch (jj_nt.kind) {
22770       case OR:
22771         jj_consume_token(OR);
22772         jj_consume_token(REPLACE);
22773         break;
22774       default:
22775         jj_la1[311] = jj_gen;
22776         ;
22777       }
22778       switch (jj_nt.kind) {
22779       case PUBLIC:
22780         jj_consume_token(PUBLIC);
22781         break;
22782       default:
22783         jj_la1[312] = jj_gen;
22784         ;
22785       }
22786       jj_consume_token(SYNONYM);
22787       simpleNode = ObjectNameDeclaration();
22788       jj_consume_token(FOR);
22789       ObjectNameDeclaration();
22790       switch (jj_nt.kind) {
22791       case 4:
22792         jj_consume_token(4);
22793         break;
22794       case 1:
22795         jj_consume_token(1);
22796         break;
22797       default:
22798         jj_la1[313] = jj_gen;
22799         jj_consume_token(-1);
22800         throw new ParseException();
22801       }
22802     jjtree.closeNodeScope(jjtn000, true);
22803     jjtc000 = false;
22804     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22805     } catch (Throwable jjte000) {
22806     if (jjtc000) {
22807       jjtree.clearNodeScope(jjtn000);
22808       jjtc000 = false;
22809     } else {
22810       jjtree.popNode();
22811     }
22812     if (jjte000 instanceof RuntimeException) {
22813       {if (true) throw (RuntimeException)jjte000;}
22814     }
22815     if (jjte000 instanceof ParseException) {
22816       {if (true) throw (ParseException)jjte000;}
22817     }
22818     {if (true) throw (Error)jjte000;}
22819     } finally {
22820     if (jjtc000) {
22821       jjtree.closeNodeScope(jjtn000, true);
22822     }
22823     }
22824     throw new Error("Missing return statement in function");
22825   }
22826 
22827   final public ASTDirectory Directory() throws ParseException {
22828  /*@bgen(jjtree) Directory */
22829  ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22830  boolean jjtc000 = true;
22831  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22832     try {
22833       jj_consume_token(CREATE);
22834       switch (jj_nt.kind) {
22835       case OR:
22836         jj_consume_token(OR);
22837         jj_consume_token(REPLACE);
22838         break;
22839       default:
22840         jj_la1[314] = jj_gen;
22841         ;
22842       }
22843       jj_consume_token(DIRECTORY);
22844       simpleNode = ObjectNameDeclaration();
22845       jj_consume_token(AS);
22846       StringLiteral();
22847       switch (jj_nt.kind) {
22848       case 4:
22849         jj_consume_token(4);
22850         break;
22851       case 1:
22852         jj_consume_token(1);
22853         break;
22854       default:
22855         jj_la1[315] = jj_gen;
22856         jj_consume_token(-1);
22857         throw new ParseException();
22858       }
22859     jjtree.closeNodeScope(jjtn000, true);
22860     jjtc000 = false;
22861     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22862     } catch (Throwable jjte000) {
22863     if (jjtc000) {
22864       jjtree.clearNodeScope(jjtn000);
22865       jjtc000 = false;
22866     } else {
22867       jjtree.popNode();
22868     }
22869     if (jjte000 instanceof RuntimeException) {
22870       {if (true) throw (RuntimeException)jjte000;}
22871     }
22872     if (jjte000 instanceof ParseException) {
22873       {if (true) throw (ParseException)jjte000;}
22874     }
22875     {if (true) throw (Error)jjte000;}
22876     } finally {
22877     if (jjtc000) {
22878       jjtree.closeNodeScope(jjtn000, true);
22879     }
22880     }
22881     throw new Error("Missing return statement in function");
22882   }
22883 
22884   final public ASTDatabaseLink DatabaseLink() throws ParseException {
22885  /*@bgen(jjtree) DatabaseLink */
22886  ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22887  boolean jjtc000 = true;
22888  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22889     try {
22890       jj_consume_token(CREATE);
22891       switch (jj_nt.kind) {
22892       case SHARED:
22893         jj_consume_token(SHARED);
22894         break;
22895       default:
22896         jj_la1[316] = jj_gen;
22897         ;
22898       }
22899       switch (jj_nt.kind) {
22900       case PUBLIC:
22901         jj_consume_token(PUBLIC);
22902         break;
22903       default:
22904         jj_la1[317] = jj_gen;
22905         ;
22906       }
22907       jj_consume_token(DATABASE);
22908       jj_consume_token(LINK);
22909       simpleNode = ObjectNameDeclaration();
22910       switch (jj_nt.kind) {
22911       case CONNECT:
22912         jj_consume_token(CONNECT);
22913         jj_consume_token(TO);
22914         switch (jj_nt.kind) {
22915         case CURRENT_USER:
22916           jj_consume_token(CURRENT_USER);
22917           break;
22918         case REPLACE:
22919         case DEFINER:
22920         case LANGUAGE:
22921         case INLINE:
22922         case ADD:
22923         case AGGREGATE:
22924         case ARRAY:
22925         case AT:
22926         case ATTRIBUTE:
22927         case AUTHID:
22928         case BODY:
22929         case BULK:
22930         case BYTE:
22931         case CASCADE:
22932         case CLOSE:
22933         case COALESCE:
22934         case COLLECT:
22935         case COLUMN:
22936         case COMMENT:
22937         case COMMIT:
22938         case CONSTRUCTOR:
22939         case CONTINUE:
22940         case CONVERT:
22941         case CURRENT:
22942         case CURSOR:
22943         case DATA:
22944         case DAY:
22945         case DISABLE:
22946         case EDITIONABLE:
22947         case ELEMENT:
22948         case ENABLE:
22949         case ESCAPE:
22950         case EXCEPT:
22951         case EXCEPTIONS:
22952         case EXIT:
22953         case EXTERNAL:
22954         case EXTENDS:
22955         case EXTRACT:
22956         case FALSE:
22957         case FINAL:
22958         case FORCE:
22959         case FUNCTION:
22960         case GLOBAL:
22961         case HASH:
22962         case HEAP:
22963         case HOUR:
22964         case IMMEDIATE:
22965         case INDICES:
22966         case INDEXTYPE:
22967         case INDICATOR:
22968         case INSTANTIABLE:
22969         case INTERVAL:
22970         case INVALIDATE:
22971         case ISOLATION:
22972         case JAVA:
22973         case LEVEL:
22974         case LIMIT:
22975         case LOOP:
22976         case MAP:
22977         case MAX:
22978         case MEMBER:
22979         case MERGE:
22980         case MIN:
22981         case MINUTE:
22982         case MLSLABEL:
22983         case MODIFY:
22984         case MOD:
22985         case MONTH:
22986         case NATURAL:
22987         case NEW:
22988         case NO:
22989         case NONEDITIONABLE:
22990         case NULLIF:
22991         case OBJECT:
22992         case OID:
22993         case OPAQUE:
22994         case OPEN:
22995         case OPERATOR:
22996         case ORGANIZATION:
22997         case OTHERS:
22998         case OVERRIDING:
22999         case PACKAGE:
23000         case PARTITION:
23001         case PRESERVE:
23002         case PRIVATE:
23003         case PROCEDURE:
23004         case RANGE:
23005         case RAW:
23006         case REAL:
23007         case RECORD:
23008         case REF:
23009         case RELEASE:
23010         case RELIES_ON:
23011         case RENAME:
23012         case RESULT:
23013         case RETURN:
23014         case RETURNING:
23015         case REVERSE:
23016         case ROLLBACK:
23017         case ROW:
23018         case ROWS:
23019         case ROWID:
23020         case ROWNUM:
23021         case SAVE:
23022         case SAVEPOINT:
23023         case SECOND:
23024         case SELF:
23025         case SET:
23026         case SPACE:
23027         case SQL:
23028         case SQLCODE:
23029         case SQLERRM:
23030         case STATIC:
23031         case SUBTYPE:
23032         case SUBSTITUTABLE:
23033         case SUCCESSFUL:
23034         case SYSDATE:
23035         case SYS_REFCURSOR:
23036         case TEMPORARY:
23037         case TIME:
23038         case TIMESTAMP:
23039         case TIMEZONE_REGION:
23040         case TIMEZONE_ABBR:
23041         case TIMEZONE_MINUTE:
23042         case TIMEZONE_HOUR:
23043         case TRANSACTION:
23044         case TRUE:
23045         case TYPE:
23046         case UNDER:
23047         case USING:
23048         case YES:
23049         case SHOW:
23050         case A:
23051         case DOUBLE:
23052         case DEC:
23053         case PRECISION:
23054         case INT:
23055         case NUMERIC:
23056         case NCHAR:
23057         case NVARCHAR2:
23058         case STRING:
23059         case UROWID:
23060         case VARRAY:
23061         case VARYING:
23062         case BFILE:
23063         case BLOB:
23064         case CLOB:
23065         case NCLOB:
23066         case YEAR:
23067         case LOCAL:
23068         case ZONE:
23069         case CHARACTER:
23070         case AFTER:
23071         case BEFORE:
23072         case OLD:
23073         case PARENT:
23074         case ANALYZE:
23075         case ASSOCIATE:
23076         case AUDIT:
23077         case COMPOUND:
23078         case DATABASE:
23079         case CALL:
23080         case DDL:
23081         case DISASSOCIATE:
23082         case EACH:
23083         case FOLLOWS:
23084         case LOGOFF:
23085         case LOGON:
23086         case NESTED:
23087         case NOAUDIT:
23088         case SCHEMA:
23089         case SERVERERROR:
23090         case SHUTDOWN:
23091         case STARTUP:
23092         case STATEMENT:
23093         case STATISTICS:
23094         case SUSPEND:
23095         case TRUNCATE:
23096         case WRAPPED:
23097         case LIBRARY:
23098         case NAME:
23099         case STRUCT:
23100         case CONTEXT:
23101         case PARAMETERS:
23102         case LENGTH:
23103         case TDO:
23104         case MAXLEN:
23105         case CHARSETID:
23106         case CHARSETFORM:
23107         case ACCEPT:
23108         case ACCESSIBLE:
23109         case COPY:
23110         case DEFINE:
23111         case DISCONNECT:
23112         case HOST:
23113         case PRINT:
23114         case QUIT:
23115         case REMARK:
23116         case UNDEFINE:
23117         case VARIABLE:
23118         case WHENEVER:
23119         case ATTACH:
23120         case CAST:
23121         case TREAT:
23122         case TRIM:
23123         case LEFT:
23124         case RIGHT:
23125         case BOTH:
23126         case EMPTY:
23127         case MULTISET:
23128         case SUBMULTISET:
23129         case LEADING:
23130         case TRAILING:
23131         case CHAR_CS:
23132         case NCHAR_CS:
23133         case DBTIMEZONE:
23134         case SESSIONTIMEZONE:
23135         case AUTHENTICATED:
23136         case LINK:
23137         case SHARED:
23138         case DIRECTORY:
23139         case USER:
23140         case IDENTIFIER:
23141         case QUOTED_LITERAL:
23142           UnqualifiedID();
23143           jj_consume_token(IDENTIFIED);
23144           jj_consume_token(BY);
23145           UnqualifiedID();
23146           jj_consume_token(AUTHENTICATED);
23147           jj_consume_token(BY);
23148           UnqualifiedID();
23149           jj_consume_token(IDENTIFIED);
23150           jj_consume_token(BY);
23151           UnqualifiedID();
23152           break;
23153         default:
23154           jj_la1[318] = jj_gen;
23155           jj_consume_token(-1);
23156           throw new ParseException();
23157         }
23158         break;
23159       case REPLACE:
23160       case DEFINER:
23161       case CURRENT_USER:
23162       case LANGUAGE:
23163       case INLINE:
23164       case ADD:
23165       case AGGREGATE:
23166       case ARRAY:
23167       case AT:
23168       case ATTRIBUTE:
23169       case AUTHID:
23170       case BODY:
23171       case BULK:
23172       case BYTE:
23173       case CASCADE:
23174       case CLOSE:
23175       case COALESCE:
23176       case COLLECT:
23177       case COLUMN:
23178       case COMMENT:
23179       case COMMIT:
23180       case CONSTRUCTOR:
23181       case CONTINUE:
23182       case CONVERT:
23183       case CURRENT:
23184       case CURSOR:
23185       case DATA:
23186       case DAY:
23187       case DISABLE:
23188       case EDITIONABLE:
23189       case ELEMENT:
23190       case ENABLE:
23191       case ESCAPE:
23192       case EXCEPT:
23193       case EXCEPTIONS:
23194       case EXIT:
23195       case EXTERNAL:
23196       case EXTENDS:
23197       case EXTRACT:
23198       case FALSE:
23199       case FINAL:
23200       case FORCE:
23201       case FUNCTION:
23202       case GLOBAL:
23203       case HASH:
23204       case HEAP:
23205       case HOUR:
23206       case IMMEDIATE:
23207       case INDICES:
23208       case INDEXTYPE:
23209       case INDICATOR:
23210       case INSTANTIABLE:
23211       case INTERVAL:
23212       case INVALIDATE:
23213       case ISOLATION:
23214       case JAVA:
23215       case LEVEL:
23216       case LIMIT:
23217       case LOOP:
23218       case MAP:
23219       case MAX:
23220       case MEMBER:
23221       case MERGE:
23222       case MIN:
23223       case MINUTE:
23224       case MLSLABEL:
23225       case MODIFY:
23226       case MOD:
23227       case MONTH:
23228       case NATURAL:
23229       case NEW:
23230       case NO:
23231       case NONEDITIONABLE:
23232       case NULLIF:
23233       case OBJECT:
23234       case OID:
23235       case OPAQUE:
23236       case OPEN:
23237       case OPERATOR:
23238       case ORGANIZATION:
23239       case OTHERS:
23240       case OVERRIDING:
23241       case PACKAGE:
23242       case PARTITION:
23243       case PRESERVE:
23244       case PRIVATE:
23245       case PROCEDURE:
23246       case RANGE:
23247       case RAW:
23248       case REAL:
23249       case RECORD:
23250       case REF:
23251       case RELEASE:
23252       case RELIES_ON:
23253       case RENAME:
23254       case RESULT:
23255       case RETURN:
23256       case RETURNING:
23257       case REVERSE:
23258       case ROLLBACK:
23259       case ROW:
23260       case ROWS:
23261       case ROWID:
23262       case ROWNUM:
23263       case SAVE:
23264       case SAVEPOINT:
23265       case SECOND:
23266       case SELF:
23267       case SET:
23268       case SPACE:
23269       case SQL:
23270       case SQLCODE:
23271       case SQLERRM:
23272       case STATIC:
23273       case SUBTYPE:
23274       case SUBSTITUTABLE:
23275       case SUCCESSFUL:
23276       case SYSDATE:
23277       case SYS_REFCURSOR:
23278       case TEMPORARY:
23279       case TIME:
23280       case TIMESTAMP:
23281       case TIMEZONE_REGION:
23282       case TIMEZONE_ABBR:
23283       case TIMEZONE_MINUTE:
23284       case TIMEZONE_HOUR:
23285       case TRANSACTION:
23286       case TRUE:
23287       case TYPE:
23288       case UNDER:
23289       case USING:
23290       case YES:
23291       case SHOW:
23292       case A:
23293       case DOUBLE:
23294       case DEC:
23295       case PRECISION:
23296       case INT:
23297       case NUMERIC:
23298       case NCHAR:
23299       case NVARCHAR2:
23300       case STRING:
23301       case UROWID:
23302       case VARRAY:
23303       case VARYING:
23304       case BFILE:
23305       case BLOB:
23306       case CLOB:
23307       case NCLOB:
23308       case YEAR:
23309       case LOCAL:
23310       case ZONE:
23311       case CHARACTER:
23312       case AFTER:
23313       case BEFORE:
23314       case OLD:
23315       case PARENT:
23316       case ANALYZE:
23317       case ASSOCIATE:
23318       case AUDIT:
23319       case COMPOUND:
23320       case DATABASE:
23321       case CALL:
23322       case DDL:
23323       case DISASSOCIATE:
23324       case EACH:
23325       case FOLLOWS:
23326       case LOGOFF:
23327       case LOGON:
23328       case NESTED:
23329       case NOAUDIT:
23330       case SCHEMA:
23331       case SERVERERROR:
23332       case SHUTDOWN:
23333       case STARTUP:
23334       case STATEMENT:
23335       case STATISTICS:
23336       case SUSPEND:
23337       case TRUNCATE:
23338       case WRAPPED:
23339       case LIBRARY:
23340       case NAME:
23341       case STRUCT:
23342       case CONTEXT:
23343       case PARAMETERS:
23344       case LENGTH:
23345       case TDO:
23346       case MAXLEN:
23347       case CHARSETID:
23348       case CHARSETFORM:
23349       case ACCEPT:
23350       case ACCESSIBLE:
23351       case COPY:
23352       case DEFINE:
23353       case DISCONNECT:
23354       case HOST:
23355       case PRINT:
23356       case QUIT:
23357       case REMARK:
23358       case UNDEFINE:
23359       case VARIABLE:
23360       case WHENEVER:
23361       case ATTACH:
23362       case CAST:
23363       case TREAT:
23364       case TRIM:
23365       case LEFT:
23366       case RIGHT:
23367       case BOTH:
23368       case EMPTY:
23369       case MULTISET:
23370       case SUBMULTISET:
23371       case LEADING:
23372       case TRAILING:
23373       case CHAR_CS:
23374       case NCHAR_CS:
23375       case DBTIMEZONE:
23376       case SESSIONTIMEZONE:
23377       case AUTHENTICATED:
23378       case LINK:
23379       case SHARED:
23380       case DIRECTORY:
23381       case USER:
23382       case IDENTIFIER:
23383       case QUOTED_LITERAL:
23384         UnqualifiedID();
23385         jj_consume_token(IDENTIFIED);
23386         jj_consume_token(BY);
23387         UnqualifiedID();
23388         break;
23389       default:
23390         jj_la1[319] = jj_gen;
23391         jj_consume_token(-1);
23392         throw new ParseException();
23393       }
23394       switch (jj_nt.kind) {
23395       case USING:
23396         jj_consume_token(USING);
23397         StringLiteral();
23398         break;
23399       default:
23400         jj_la1[320] = jj_gen;
23401         ;
23402       }
23403       switch (jj_nt.kind) {
23404       case 4:
23405         jj_consume_token(4);
23406         break;
23407       case 1:
23408         jj_consume_token(1);
23409         break;
23410       default:
23411         jj_la1[321] = jj_gen;
23412         jj_consume_token(-1);
23413         throw new ParseException();
23414       }
23415     jjtree.closeNodeScope(jjtn000, true);
23416     jjtc000 = false;
23417     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
23418     } catch (Throwable jjte000) {
23419     if (jjtc000) {
23420       jjtree.clearNodeScope(jjtn000);
23421       jjtc000 = false;
23422     } else {
23423       jjtree.popNode();
23424     }
23425     if (jjte000 instanceof RuntimeException) {
23426       {if (true) throw (RuntimeException)jjte000;}
23427     }
23428     if (jjte000 instanceof ParseException) {
23429       {if (true) throw (ParseException)jjte000;}
23430     }
23431     {if (true) throw (Error)jjte000;}
23432     } finally {
23433     if (jjtc000) {
23434       jjtree.closeNodeScope(jjtn000, true);
23435     }
23436     }
23437     throw new Error("Missing return statement in function");
23438   }
23439 
23440   final public ASTViewColumn ViewColumn() throws ParseException {
23441  /*@bgen(jjtree) ViewColumn */
23442   ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23443   boolean jjtc000 = true;
23444   jjtree.openNodeScope(jjtn000);
23445     try {
23446       ID();
23447         jjtree.closeNodeScope(jjtn000, true);
23448         jjtc000 = false;
23449         {if (true) return jjtn000 ;}
23450     } catch (Throwable jjte000) {
23451     if (jjtc000) {
23452       jjtree.clearNodeScope(jjtn000);
23453       jjtc000 = false;
23454     } else {
23455       jjtree.popNode();
23456     }
23457     if (jjte000 instanceof RuntimeException) {
23458       {if (true) throw (RuntimeException)jjte000;}
23459     }
23460     if (jjte000 instanceof ParseException) {
23461       {if (true) throw (ParseException)jjte000;}
23462     }
23463     {if (true) throw (Error)jjte000;}
23464     } finally {
23465     if (jjtc000) {
23466       jjtree.closeNodeScope(jjtn000, true);
23467     }
23468     }
23469     throw new Error("Missing return statement in function");
23470   }
23471 
23472   final public ASTComment Comment() throws ParseException {
23473  /*@bgen(jjtree) Comment */
23474   ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23475   boolean jjtc000 = true;
23476   jjtree.openNodeScope(jjtn000);
23477     try {
23478       jj_consume_token(COMMENT);
23479       jj_consume_token(ON);
23480       switch (jj_nt.kind) {
23481       case INDEXTYPE:
23482       case OPERATOR:
23483       case TABLE:
23484         switch (jj_nt.kind) {
23485         case TABLE:
23486           jj_consume_token(TABLE);
23487           break;
23488         case OPERATOR:
23489           jj_consume_token(OPERATOR);
23490           break;
23491         case INDEXTYPE:
23492           jj_consume_token(INDEXTYPE);
23493           break;
23494         default:
23495           jj_la1[322] = jj_gen;
23496           jj_consume_token(-1);
23497           throw new ParseException();
23498         }
23499         if (jj_2_61(2)) {
23500           ID();
23501           jj_consume_token(3);
23502         } else {
23503           ;
23504         }
23505         ID();
23506         break;
23507       case COLUMN:
23508         jj_consume_token(COLUMN);
23509         if (jj_2_62(2147483647)) {
23510           ID();
23511           jj_consume_token(3);
23512         } else {
23513           ;
23514         }
23515         ID();
23516         jj_consume_token(3);
23517         ID();
23518         break;
23519       default:
23520         jj_la1[323] = jj_gen;
23521         jj_consume_token(-1);
23522         throw new ParseException();
23523       }
23524       jj_consume_token(IS);
23525       jj_consume_token(STRING_LITERAL);
23526       switch (jj_nt.kind) {
23527       case 4:
23528         jj_consume_token(4);
23529         break;
23530       default:
23531         jj_la1[324] = jj_gen;
23532         ;
23533       }
23534         jjtree.closeNodeScope(jjtn000, true);
23535         jjtc000 = false;
23536         {if (true) return jjtn000 ;}
23537     } catch (Throwable jjte000) {
23538     if (jjtc000) {
23539       jjtree.clearNodeScope(jjtn000);
23540       jjtc000 = false;
23541     } else {
23542       jjtree.popNode();
23543     }
23544     if (jjte000 instanceof RuntimeException) {
23545       {if (true) throw (RuntimeException)jjte000;}
23546     }
23547     if (jjte000 instanceof ParseException) {
23548       {if (true) throw (ParseException)jjte000;}
23549     }
23550     {if (true) throw (Error)jjte000;}
23551     } finally {
23552     if (jjtc000) {
23553       jjtree.closeNodeScope(jjtn000, true);
23554     }
23555     }
23556     throw new Error("Missing return statement in function");
23557   }
23558 
23559 // SRT * /
23560   final public ASTTypeMethod TypeMethod() throws ParseException {
23561  /*@bgen(jjtree) TypeMethod */
23562   ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23563   boolean jjtc000 = true;
23564   jjtree.openNodeScope(jjtn000);
23565     try {
23566         getToken(1);
23567         //System.err.println("typeMethod: Result of getToken(1) is \"" + startToken.toString() + "\"" );
23568 
23569       label_73:
23570       while (true) {
23571         switch (jj_nt.kind) {
23572         case FINAL:
23573         case INSTANTIABLE:
23574         case NOT:
23575         case OVERRIDING:
23576           ;
23577           break;
23578         default:
23579           jj_la1[325] = jj_gen;
23580           break label_73;
23581         }
23582         switch (jj_nt.kind) {
23583         case NOT:
23584           jj_consume_token(NOT);
23585           break;
23586         default:
23587           jj_la1[326] = jj_gen;
23588           ;
23589         }
23590         switch (jj_nt.kind) {
23591         case OVERRIDING:
23592           jj_consume_token(OVERRIDING);
23593           break;
23594         case INSTANTIABLE:
23595           jj_consume_token(INSTANTIABLE);
23596           break;
23597         case FINAL:
23598           jj_consume_token(FINAL);
23599           break;
23600         default:
23601           jj_la1[327] = jj_gen;
23602           jj_consume_token(-1);
23603           throw new ParseException();
23604         }
23605       }
23606       switch (jj_nt.kind) {
23607       case MAP:
23608       case ORDER:
23609         switch (jj_nt.kind) {
23610         case MAP:
23611           jj_consume_token(MAP);
23612           break;
23613         case ORDER:
23614           jj_consume_token(ORDER);
23615           break;
23616         default:
23617           jj_la1[328] = jj_gen;
23618           jj_consume_token(-1);
23619           throw new ParseException();
23620         }
23621         break;
23622       default:
23623         jj_la1[329] = jj_gen;
23624         ;
23625       }
23626       switch (jj_nt.kind) {
23627       case CONSTRUCTOR:
23628         jj_consume_token(CONSTRUCTOR);
23629         break;
23630       case MEMBER:
23631         jj_consume_token(MEMBER);
23632         break;
23633       case STATIC:
23634         jj_consume_token(STATIC);
23635         break;
23636       default:
23637         jj_la1[330] = jj_gen;
23638         jj_consume_token(-1);
23639         throw new ParseException();
23640       }
23641       MethodDeclarator();
23642       switch (jj_nt.kind) {
23643       case DETERMINISTIC:
23644         jj_consume_token(DETERMINISTIC);
23645         break;
23646       default:
23647         jj_la1[331] = jj_gen;
23648         ;
23649       }
23650       switch (jj_nt.kind) {
23651       case PARALLEL_ENABLE:
23652         jj_consume_token(PARALLEL_ENABLE);
23653         break;
23654       default:
23655         jj_la1[332] = jj_gen;
23656         ;
23657       }
23658       switch (jj_nt.kind) {
23659       case PIPELINED:
23660         jj_consume_token(PIPELINED);
23661         break;
23662       default:
23663         jj_la1[333] = jj_gen;
23664         ;
23665       }
23666       switch (jj_nt.kind) {
23667       case RESULT_CACHE:
23668         jj_consume_token(RESULT_CACHE);
23669         break;
23670       default:
23671         jj_la1[334] = jj_gen;
23672         ;
23673       }
23674       switch (jj_nt.kind) {
23675       case AS:
23676       case IS:
23677         switch (jj_nt.kind) {
23678         case IS:
23679           jj_consume_token(IS);
23680           break;
23681         case AS:
23682           jj_consume_token(AS);
23683           break;
23684         default:
23685           jj_la1[335] = jj_gen;
23686           jj_consume_token(-1);
23687           throw new ParseException();
23688         }
23689         switch (jj_nt.kind) {
23690         case LANGUAGE:
23691         case EXTERNAL:
23692           CallSpecTail();
23693           switch (jj_nt.kind) {
23694           case 4:
23695             jj_consume_token(4);
23696             break;
23697           default:
23698             jj_la1[336] = jj_gen;
23699             ;
23700           }
23701           break;
23702         case REPLACE:
23703         case DEFINER:
23704         case CURRENT_USER:
23705         case SERIALLY_REUSABLE:
23706         case RESTRICT_REFERENCES:
23707         case EXCEPTION_INIT:
23708         case AUTONOMOUS_TRANSACTION:
23709         case INLINE:
23710         case ADD:
23711         case AGGREGATE:
23712         case ALL:
23713         case ALTER:
23714         case AND:
23715         case ANY:
23716         case ARRAY:
23717         case AS:
23718         case ASC:
23719         case AT:
23720         case ATTRIBUTE:
23721         case AUTHID:
23722         case AVG:
23723         case BEGIN:
23724         case BETWEEN:
23725         case BINARY_INTEGER:
23726         case BODY:
23727         case BOOLEAN:
23728         case BULK:
23729         case BY:
23730         case BYTE:
23731         case CASCADE:
23732         case CASE:
23733         case CHAR:
23734         case CHAR_BASE:
23735         case CHECK:
23736         case CLOSE:
23737         case CLUSTER:
23738         case COALESCE:
23739         case COLLECT:
23740         case COLUMN:
23741         case COMMENT:
23742         case COMMIT:
23743         case COMPRESS:
23744         case CONNECT:
23745         case CONSTANT:
23746         case CONSTRUCTOR:
23747         case CONTINUE:
23748         case CONVERT:
23749         case CREATE:
23750         case CURRENT:
23751         case CURRVAL:
23752         case CURSOR:
23753         case DATA:
23754         case DATE:
23755         case DAY:
23756         case DECLARE:
23757         case DECIMAL:
23758         case _DEFAULT:
23759         case DELETE:
23760         case DESC:
23761         case DISABLE:
23762         case DISTINCT:
23763         case DO:
23764         case DROP:
23765         case EDITIONABLE:
23766         case ELEMENT:
23767         case ELSE:
23768         case ELSIF:
23769         case ENABLE:
23770         case ESCAPE:
23771         case EXCEPT:
23772         case EXCEPTION:
23773         case EXCEPTIONS:
23774         case EXCLUSIVE:
23775         case EXECUTE:
23776         case EXISTS:
23777         case EXIT:
23778         case EXTENDS:
23779         case EXTRACT:
23780         case FALSE:
23781         case FETCH:
23782         case FINAL:
23783         case FLOAT:
23784         case FOR:
23785         case FORALL:
23786         case FORCE:
23787         case FROM:
23788         case FUNCTION:
23789         case GLOBAL:
23790         case GOTO:
23791         case GROUP:
23792         case HASH:
23793         case HAVING:
23794         case HEAP:
23795         case HOUR:
23796         case IF:
23797         case IMMEDIATE:
23798         case IN:
23799         case INDEX:
23800         case INDICES:
23801         case INDEXTYPE:
23802         case INDICATOR:
23803         case INSERT:
23804         case INSTANTIABLE:
23805         case INTEGER:
23806         case INTERFACE:
23807         case INTERSECT:
23808         case INTERVAL:
23809         case INTO:
23810         case INVALIDATE:
23811         case IS:
23812         case ISOLATION:
23813         case JAVA:
23814         case LEVEL:
23815         case LIKE:
23816         case LIMIT:
23817         case LIMITED:
23818         case LOCK:
23819         case LONG:
23820         case LOOP:
23821         case MAP:
23822         case MAX:
23823         case MEMBER:
23824         case MERGE:
23825         case MIN:
23826         case MINUS:
23827         case MINUTE:
23828         case MLSLABEL:
23829         case MODIFY:
23830         case MOD:
23831         case MODE:
23832         case MONTH:
23833         case NATURAL:
23834         case NATURALN:
23835         case NEW:
23836         case NEXTVAL:
23837         case NO:
23838         case NOCOPY:
23839         case NONEDITIONABLE:
23840         case NOT:
23841         case NOWAIT:
23842         case NULL:
23843         case NULLIF:
23844         case NUMBER:
23845         case BFILE_BASE:
23846         case BLOB_BASE:
23847         case CLOB_BASE:
23848         case DATE_BASE:
23849         case NUMBER_BASE:
23850         case OBJECT:
23851         case OCIROWID:
23852         case OF:
23853         case OID:
23854         case ON:
23855         case OPAQUE:
23856         case OPEN:
23857         case OPERATOR:
23858         case OPTION:
23859         case OR:
23860         case ORDER:
23861         case ORGANIZATION:
23862         case OTHERS:
23863         case OUT:
23864         case OVERRIDING:
23865         case PACKAGE:
23866         case PARTITION:
23867         case PCTFREE:
23868         case PLS_INTEGER:
23869         case POSITIVE:
23870         case POSITIVEN:
23871         case PRAGMA:
23872         case PRESERVE:
23873         case PRIOR:
23874         case PROMPT:
23875         case PRIVATE:
23876         case PROCEDURE:
23877         case PUBLIC:
23878         case RAISE:
23879         case RANGE:
23880         case RAW:
23881         case REAL:
23882         case RECORD:
23883         case REF:
23884         case RELEASE:
23885         case RELIES_ON:
23886         case RENAME:
23887         case RESULT:
23888         case RETURN:
23889         case RETURNING:
23890         case REVERSE:
23891         case ROLLBACK:
23892         case ROW:
23893         case ROWS:
23894         case ROWID:
23895         case ROWNUM:
23896         case ROWTYPE:
23897         case SAVE:
23898         case SAVEPOINT:
23899         case SECOND:
23900         case SELECT:
23901         case SELF:
23902         case SEPARATE:
23903         case SET:
23904         case SHARE:
23905         case SMALLINT:
23906         case SPACE:
23907         case SQL:
23908         case SQLCODE:
23909         case SQLERRM:
23910         case START:
23911         case STATIC:
23912         case STDDEV:
23913         case SUBTYPE:
23914         case SUBSTITUTABLE:
23915         case SUCCESSFUL:
23916         case SUM:
23917         case SYNONYM:
23918         case SYSDATE:
23919         case SYS_REFCURSOR:
23920         case TABLE:
23921         case TEMPORARY:
23922         case THEN:
23923         case TIME:
23924         case TIMESTAMP:
23925         case TIMEZONE_REGION:
23926         case TIMEZONE_ABBR:
23927         case TIMEZONE_MINUTE:
23928         case TIMEZONE_HOUR:
23929         case TO:
23930         case TRANSACTION:
23931         case TRIGGER:
23932         case TRUE:
23933         case TYPE:
23934         case UI:
23935         case UNDER:
23936         case USING:
23937         case WHILE:
23938         case YES:
23939         case SHOW:
23940         case A:
23941         case UPDATE:
23942         case VARCHAR:
23943         case VARCHAR2:
23944         case DOUBLE:
23945         case DEC:
23946         case PRECISION:
23947         case INT:
23948         case NUMERIC:
23949         case SIGNTYPE:
23950         case NCHAR:
23951         case NVARCHAR2:
23952         case STRING:
23953         case UROWID:
23954         case VARRAY:
23955         case VARYING:
23956         case BFILE:
23957         case BLOB:
23958         case CLOB:
23959         case NCLOB:
23960         case YEAR:
23961         case LOCAL:
23962         case WITH:
23963         case ZONE:
23964         case CHARACTER:
23965         case AFTER:
23966         case BEFORE:
23967         case OLD:
23968         case PARENT:
23969         case CC_IF:
23970         case ANALYZE:
23971         case ASSOCIATE:
23972         case AUDIT:
23973         case COMPOUND:
23974         case DATABASE:
23975         case CALL:
23976         case DDL:
23977         case DISASSOCIATE:
23978         case EACH:
23979         case FOLLOWS:
23980         case LOGOFF:
23981         case LOGON:
23982         case NESTED:
23983         case NOAUDIT:
23984         case SCHEMA:
23985         case SERVERERROR:
23986         case SHUTDOWN:
23987         case STARTUP:
23988         case STATEMENT:
23989         case STATISTICS:
23990         case SUSPEND:
23991         case TRUNCATE:
23992         case WRAPPED:
23993         case LIBRARY:
23994         case NAME:
23995         case STRUCT:
23996         case CONTEXT:
23997         case PARAMETERS:
23998         case LENGTH:
23999         case TDO:
24000         case MAXLEN:
24001         case CHARSETID:
24002         case CHARSETFORM:
24003         case ACCEPT:
24004         case ACCESSIBLE:
24005         case COPY:
24006         case DEFINE:
24007         case DISCONNECT:
24008         case HOST:
24009         case PRINT:
24010         case QUIT:
24011         case REMARK:
24012         case UNDEFINE:
24013         case VARIABLE:
24014         case WHENEVER:
24015         case ATTACH:
24016         case CAST:
24017         case TREAT:
24018         case TRIM:
24019         case LEFT:
24020         case RIGHT:
24021         case BOTH:
24022         case EMPTY:
24023         case MULTISET:
24024         case SUBMULTISET:
24025         case LEADING:
24026         case TRAILING:
24027         case CHAR_CS:
24028         case NCHAR_CS:
24029         case DBTIMEZONE:
24030         case SESSIONTIMEZONE:
24031         case AUTHENTICATED:
24032         case LINK:
24033         case SHARED:
24034         case DIRECTORY:
24035         case USER:
24036         case IDENTIFIER:
24037         case QUOTED_LITERAL:
24038         case SQLDATA_CLASS:
24039         case CUSTOMDATUM_CLASS:
24040         case ORADATA_CLASS:
24041         case JAVA_INTERFACE_CLASS:
24042           DeclarativeSection();
24043           jj_consume_token(BEGIN);
24044           label_74:
24045           while (true) {
24046             switch (jj_nt.kind) {
24047             case 5:
24048             case 16:
24049             case 17:
24050             case 21:
24051             case REPLACE:
24052             case DEFINER:
24053             case CURRENT_USER:
24054             case LANGUAGE:
24055             case INLINE:
24056             case ADD:
24057             case AGGREGATE:
24058             case ARRAY:
24059             case AT:
24060             case ATTRIBUTE:
24061             case AUTHID:
24062             case BEGIN:
24063             case BODY:
24064             case BULK:
24065             case BYTE:
24066             case CASCADE:
24067             case CASE:
24068             case CLOSE:
24069             case COALESCE:
24070             case COLLECT:
24071             case COLUMN:
24072             case COMMENT:
24073             case COMMIT:
24074             case CONSTRUCTOR:
24075             case CONTINUE:
24076             case CONVERT:
24077             case CURRENT:
24078             case CURSOR:
24079             case DATA:
24080             case DATE:
24081             case DAY:
24082             case DECLARE:
24083             case DELETE:
24084             case DISABLE:
24085             case EDITIONABLE:
24086             case ELEMENT:
24087             case ENABLE:
24088             case ESCAPE:
24089             case EXCEPT:
24090             case EXCEPTIONS:
24091             case EXECUTE:
24092             case EXIT:
24093             case EXTERNAL:
24094             case EXTENDS:
24095             case EXTRACT:
24096             case FALSE:
24097             case FETCH:
24098             case FINAL:
24099             case FOR:
24100             case FORALL:
24101             case FORCE:
24102             case FUNCTION:
24103             case GLOBAL:
24104             case GOTO:
24105             case HASH:
24106             case HEAP:
24107             case HOUR:
24108             case IF:
24109             case IMMEDIATE:
24110             case INDICES:
24111             case INDEXTYPE:
24112             case INDICATOR:
24113             case INSERT:
24114             case INSTANTIABLE:
24115             case INTERVAL:
24116             case INVALIDATE:
24117             case ISOLATION:
24118             case JAVA:
24119             case LEVEL:
24120             case LIMIT:
24121             case LOCK:
24122             case LOOP:
24123             case MAP:
24124             case MAX:
24125             case MEMBER:
24126             case MERGE:
24127             case MIN:
24128             case MINUTE:
24129             case MLSLABEL:
24130             case MODIFY:
24131             case MOD:
24132             case MONTH:
24133             case NATURAL:
24134             case NEW:
24135             case NEW_DOT:
24136             case NO:
24137             case NONEDITIONABLE:
24138             case NOT:
24139             case NULL:
24140             case NULLIF:
24141             case OBJECT:
24142             case OID:
24143             case OPAQUE:
24144             case OPEN:
24145             case OPERATOR:
24146             case ORGANIZATION:
24147             case OTHERS:
24148             case OVERRIDING:
24149             case PACKAGE:
24150             case PARTITION:
24151             case PIPE:
24152             case PRAGMA:
24153             case PRESERVE:
24154             case PRIVATE:
24155             case PROCEDURE:
24156             case RAISE:
24157             case RANGE:
24158             case RAW:
24159             case REAL:
24160             case RECORD:
24161             case REF:
24162             case RELEASE:
24163             case RELIES_ON:
24164             case RENAME:
24165             case RESULT:
24166             case RETURN:
24167             case RETURNING:
24168             case REVERSE:
24169             case ROLLBACK:
24170             case ROW:
24171             case ROWS:
24172             case ROWID:
24173             case ROWNUM:
24174             case SAVE:
24175             case SAVEPOINT:
24176             case SECOND:
24177             case SELECT:
24178             case SELF:
24179             case SET:
24180             case SPACE:
24181             case SQL:
24182             case SQLCODE:
24183             case SQLERRM:
24184             case STATIC:
24185             case SUBTYPE:
24186             case SUBSTITUTABLE:
24187             case SUCCESSFUL:
24188             case SYSDATE:
24189             case SYS_REFCURSOR:
24190             case TEMPORARY:
24191             case TIME:
24192             case TIMESTAMP:
24193             case TIMEZONE_REGION:
24194             case TIMEZONE_ABBR:
24195             case TIMEZONE_MINUTE:
24196             case TIMEZONE_HOUR:
24197             case TRANSACTION:
24198             case TRUE:
24199             case TYPE:
24200             case UNDER:
24201             case USING:
24202             case WHILE:
24203             case YES:
24204             case SHOW:
24205             case A:
24206             case UPDATE:
24207             case DOUBLE:
24208             case DEC:
24209             case PRECISION:
24210             case INT:
24211             case NUMERIC:
24212             case NCHAR:
24213             case NVARCHAR2:
24214             case STRING:
24215             case UROWID:
24216             case VARRAY:
24217             case VARYING:
24218             case BFILE:
24219             case BLOB:
24220             case CLOB:
24221             case NCLOB:
24222             case YEAR:
24223             case LOCAL:
24224             case WITH:
24225             case ZONE:
24226             case CHARACTER:
24227             case AFTER:
24228             case BEFORE:
24229             case OLD:
24230             case PARENT:
24231             case CC_IF:
24232             case CC_ERROR:
24233             case ANALYZE:
24234             case ASSOCIATE:
24235             case AUDIT:
24236             case COMPOUND:
24237             case DATABASE:
24238             case CALL:
24239             case DDL:
24240             case DISASSOCIATE:
24241             case EACH:
24242             case FOLLOWS:
24243             case LOGOFF:
24244             case LOGON:
24245             case NESTED:
24246             case NOAUDIT:
24247             case SCHEMA:
24248             case SERVERERROR:
24249             case SHUTDOWN:
24250             case STARTUP:
24251             case STATEMENT:
24252             case STATISTICS:
24253             case SUSPEND:
24254             case TRUNCATE:
24255             case WRAPPED:
24256             case LIBRARY:
24257             case NAME:
24258             case STRUCT:
24259             case CONTEXT:
24260             case PARAMETERS:
24261             case LENGTH:
24262             case TDO:
24263             case MAXLEN:
24264             case CHARSETID:
24265             case CHARSETFORM:
24266             case ACCEPT:
24267             case ACCESSIBLE:
24268             case COPY:
24269             case DEFINE:
24270             case DISCONNECT:
24271             case HOST:
24272             case PRINT:
24273             case QUIT:
24274             case REMARK:
24275             case UNDEFINE:
24276             case VARIABLE:
24277             case WHENEVER:
24278             case ATTACH:
24279             case CAST:
24280             case TREAT:
24281             case TRIM:
24282             case LEFT:
24283             case RIGHT:
24284             case BOTH:
24285             case EMPTY:
24286             case MULTISET:
24287             case SUBMULTISET:
24288             case LEADING:
24289             case TRAILING:
24290             case CHAR_CS:
24291             case NCHAR_CS:
24292             case DBTIMEZONE:
24293             case SESSIONTIMEZONE:
24294             case AUTHENTICATED:
24295             case LINK:
24296             case SHARED:
24297             case DIRECTORY:
24298             case USER:
24299             case IDENTIFIER:
24300             case UNSIGNED_NUMERIC_LITERAL:
24301             case CHARACTER_LITERAL:
24302             case STRING_LITERAL:
24303             case QUOTED_LITERAL:
24304               ;
24305               break;
24306             default:
24307               jj_la1[337] = jj_gen;
24308               break label_74;
24309             }
24310             Statement();
24311           }
24312           switch (jj_nt.kind) {
24313           case EXCEPTION:
24314             ExceptionHandler();
24315             break;
24316           default:
24317             jj_la1[338] = jj_gen;
24318             ;
24319           }
24320           jj_consume_token(END);
24321           switch (jj_nt.kind) {
24322           case REPLACE:
24323           case DEFINER:
24324           case CURRENT_USER:
24325           case SERIALLY_REUSABLE:
24326           case RESTRICT_REFERENCES:
24327           case EXCEPTION_INIT:
24328           case AUTONOMOUS_TRANSACTION:
24329           case LANGUAGE:
24330           case INLINE:
24331           case ADD:
24332           case AGGREGATE:
24333           case ALL:
24334           case ALTER:
24335           case AND:
24336           case ANY:
24337           case ARRAY:
24338           case AS:
24339           case ASC:
24340           case AT:
24341           case ATTRIBUTE:
24342           case AUTHID:
24343           case AVG:
24344           case BETWEEN:
24345           case BINARY_INTEGER:
24346           case BODY:
24347           case BOOLEAN:
24348           case BULK:
24349           case BY:
24350           case BYTE:
24351           case CASCADE:
24352           case CASE:
24353           case CHAR:
24354           case CHAR_BASE:
24355           case CHECK:
24356           case CLOSE:
24357           case CLUSTER:
24358           case COALESCE:
24359           case COLLECT:
24360           case COLUMN:
24361           case COMMENT:
24362           case COMMIT:
24363           case COMPRESS:
24364           case CONNECT:
24365           case CONSTANT:
24366           case CONSTRUCTOR:
24367           case CONTINUE:
24368           case CONVERT:
24369           case CREATE:
24370           case CURRENT:
24371           case CURRVAL:
24372           case CURSOR:
24373           case DATA:
24374           case DATE:
24375           case DAY:
24376           case DECLARE:
24377           case DECIMAL:
24378           case _DEFAULT:
24379           case DELETE:
24380           case DESC:
24381           case DISABLE:
24382           case DISTINCT:
24383           case DO:
24384           case DROP:
24385           case EDITIONABLE:
24386           case ELEMENT:
24387           case ELSE:
24388           case ELSIF:
24389           case ENABLE:
24390           case ESCAPE:
24391           case EXCEPT:
24392           case EXCEPTION:
24393           case EXCEPTIONS:
24394           case EXCLUSIVE:
24395           case EXECUTE:
24396           case EXISTS:
24397           case EXIT:
24398           case EXTERNAL:
24399           case EXTENDS:
24400           case EXTRACT:
24401           case FALSE:
24402           case FETCH:
24403           case FINAL:
24404           case FLOAT:
24405           case FOR:
24406           case FORALL:
24407           case FORCE:
24408           case FROM:
24409           case FUNCTION:
24410           case GLOBAL:
24411           case GOTO:
24412           case GROUP:
24413           case HASH:
24414           case HAVING:
24415           case HEAP:
24416           case HOUR:
24417           case IF:
24418           case IMMEDIATE:
24419           case IN:
24420           case INDEX:
24421           case INDICES:
24422           case INDEXTYPE:
24423           case INDICATOR:
24424           case INSERT:
24425           case INSTANTIABLE:
24426           case INTEGER:
24427           case INTERFACE:
24428           case INTERSECT:
24429           case INTERVAL:
24430           case INTO:
24431           case INVALIDATE:
24432           case IS:
24433           case ISOLATION:
24434           case JAVA:
24435           case LEVEL:
24436           case LIKE:
24437           case LIMIT:
24438           case LIMITED:
24439           case LOCK:
24440           case LONG:
24441           case LOOP:
24442           case MAP:
24443           case MAX:
24444           case MEMBER:
24445           case MERGE:
24446           case MIN:
24447           case MINUS:
24448           case MINUTE:
24449           case MLSLABEL:
24450           case MODIFY:
24451           case MOD:
24452           case MODE:
24453           case MONTH:
24454           case NATURAL:
24455           case NATURALN:
24456           case NEW:
24457           case NEXTVAL:
24458           case NO:
24459           case NOCOPY:
24460           case NONEDITIONABLE:
24461           case NOT:
24462           case NOWAIT:
24463           case NULL:
24464           case NULLIF:
24465           case NUMBER:
24466           case BFILE_BASE:
24467           case BLOB_BASE:
24468           case CLOB_BASE:
24469           case DATE_BASE:
24470           case NUMBER_BASE:
24471           case OBJECT:
24472           case OCIROWID:
24473           case OF:
24474           case OID:
24475           case ON:
24476           case OPAQUE:
24477           case OPEN:
24478           case OPERATOR:
24479           case OPTION:
24480           case OR:
24481           case ORDER:
24482           case ORGANIZATION:
24483           case OTHERS:
24484           case OUT:
24485           case OVERRIDING:
24486           case PACKAGE:
24487           case PARTITION:
24488           case PCTFREE:
24489           case PLS_INTEGER:
24490           case POSITIVE:
24491           case POSITIVEN:
24492           case PRESERVE:
24493           case PRIOR:
24494           case PROMPT:
24495           case PRIVATE:
24496           case PROCEDURE:
24497           case PUBLIC:
24498           case RAISE:
24499           case RANGE:
24500           case RAW:
24501           case REAL:
24502           case RECORD:
24503           case REF:
24504           case RELEASE:
24505           case RELIES_ON:
24506           case RENAME:
24507           case RESULT:
24508           case RETURN:
24509           case RETURNING:
24510           case REVERSE:
24511           case ROLLBACK:
24512           case ROW:
24513           case ROWS:
24514           case ROWID:
24515           case ROWNUM:
24516           case ROWTYPE:
24517           case SAVE:
24518           case SAVEPOINT:
24519           case SECOND:
24520           case SELECT:
24521           case SELF:
24522           case SEPARATE:
24523           case SET:
24524           case SHARE:
24525           case SMALLINT:
24526           case SPACE:
24527           case SQL:
24528           case SQLCODE:
24529           case SQLERRM:
24530           case START:
24531           case STATIC:
24532           case STDDEV:
24533           case SUBTYPE:
24534           case SUBSTITUTABLE:
24535           case SUCCESSFUL:
24536           case SUM:
24537           case SYNONYM:
24538           case SYSDATE:
24539           case SYS_REFCURSOR:
24540           case TABLE:
24541           case TEMPORARY:
24542           case THEN:
24543           case TIME:
24544           case TIMESTAMP:
24545           case TIMEZONE_REGION:
24546           case TIMEZONE_ABBR:
24547           case TIMEZONE_MINUTE:
24548           case TIMEZONE_HOUR:
24549           case TO:
24550           case TRANSACTION:
24551           case TRIGGER:
24552           case TRUE:
24553           case TYPE:
24554           case UI:
24555           case UNDER:
24556           case USING:
24557           case WHILE:
24558           case YES:
24559           case SHOW:
24560           case A:
24561           case UPDATE:
24562           case VARCHAR:
24563           case VARCHAR2:
24564           case DOUBLE:
24565           case DEC:
24566           case PRECISION:
24567           case INT:
24568           case NUMERIC:
24569           case SIGNTYPE:
24570           case NCHAR:
24571           case NVARCHAR2:
24572           case STRING:
24573           case UROWID:
24574           case VARRAY:
24575           case VARYING:
24576           case BFILE:
24577           case BLOB:
24578           case CLOB:
24579           case NCLOB:
24580           case YEAR:
24581           case LOCAL:
24582           case WITH:
24583           case ZONE:
24584           case CHARACTER:
24585           case AFTER:
24586           case BEFORE:
24587           case OLD:
24588           case PARENT:
24589           case ANALYZE:
24590           case ASSOCIATE:
24591           case AUDIT:
24592           case COMPOUND:
24593           case DATABASE:
24594           case CALL:
24595           case DDL:
24596           case DISASSOCIATE:
24597           case EACH:
24598           case FOLLOWS:
24599           case LOGOFF:
24600           case LOGON:
24601           case NESTED:
24602           case NOAUDIT:
24603           case SCHEMA:
24604           case SERVERERROR:
24605           case SHUTDOWN:
24606           case STARTUP:
24607           case STATEMENT:
24608           case STATISTICS:
24609           case SUSPEND:
24610           case TRUNCATE:
24611           case WRAPPED:
24612           case LIBRARY:
24613           case NAME:
24614           case STRUCT:
24615           case CONTEXT:
24616           case PARAMETERS:
24617           case LENGTH:
24618           case TDO:
24619           case MAXLEN:
24620           case CHARSETID:
24621           case CHARSETFORM:
24622           case ACCEPT:
24623           case ACCESSIBLE:
24624           case COPY:
24625           case DEFINE:
24626           case DISCONNECT:
24627           case HOST:
24628           case PRINT:
24629           case QUIT:
24630           case REMARK:
24631           case UNDEFINE:
24632           case VARIABLE:
24633           case WHENEVER:
24634           case ATTACH:
24635           case CAST:
24636           case TREAT:
24637           case TRIM:
24638           case LEFT:
24639           case RIGHT:
24640           case BOTH:
24641           case EMPTY:
24642           case MULTISET:
24643           case SUBMULTISET:
24644           case LEADING:
24645           case TRAILING:
24646           case CHAR_CS:
24647           case NCHAR_CS:
24648           case DBTIMEZONE:
24649           case SESSIONTIMEZONE:
24650           case AUTHENTICATED:
24651           case LINK:
24652           case SHARED:
24653           case DIRECTORY:
24654           case USER:
24655           case IDENTIFIER:
24656           case QUOTED_LITERAL:
24657           case SQLDATA_CLASS:
24658           case CUSTOMDATUM_CLASS:
24659           case ORADATA_CLASS:
24660           case JAVA_INTERFACE_CLASS:
24661             ID();
24662             break;
24663           default:
24664             jj_la1[339] = jj_gen;
24665             ;
24666           }
24667           jj_consume_token(4);
24668           break;
24669         default:
24670           jj_la1[340] = jj_gen;
24671           jj_consume_token(-1);
24672           throw new ParseException();
24673         }
24674         break;
24675       default:
24676         jj_la1[341] = jj_gen;
24677         ;
24678       }
24679         jjtree.closeNodeScope(jjtn000, true);
24680         jjtc000 = false;
24681         {if (true) return jjtn000 ;}
24682     } catch (Throwable jjte000) {
24683           if (jjtc000) {
24684             jjtree.clearNodeScope(jjtn000);
24685             jjtc000 = false;
24686           } else {
24687             jjtree.popNode();
24688           }
24689           if (jjte000 instanceof RuntimeException) {
24690             {if (true) throw (RuntimeException)jjte000;}
24691           }
24692           if (jjte000 instanceof ParseException) {
24693             {if (true) throw (ParseException)jjte000;}
24694           }
24695           {if (true) throw (Error)jjte000;}
24696     } finally {
24697           if (jjtc000) {
24698             jjtree.closeNodeScope(jjtn000, true);
24699           }
24700     }
24701     throw new Error("Missing return statement in function");
24702   }
24703 
24704   final public ASTTypeSpecification TypeSpecification() throws ParseException {
24705  /*@bgen(jjtree) TypeSpecification */
24706  ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24707  boolean jjtc000 = true;
24708  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24709     try {
24710       switch (jj_nt.kind) {
24711       case CREATE:
24712         jj_consume_token(CREATE);
24713         switch (jj_nt.kind) {
24714         case OR:
24715           jj_consume_token(OR);
24716           jj_consume_token(REPLACE);
24717           break;
24718         default:
24719           jj_la1[342] = jj_gen;
24720           ;
24721         }
24722         switch (jj_nt.kind) {
24723         case EDITIONABLE:
24724         case NONEDITIONABLE:
24725           switch (jj_nt.kind) {
24726           case EDITIONABLE:
24727             jj_consume_token(EDITIONABLE);
24728             break;
24729           case NONEDITIONABLE:
24730             jj_consume_token(NONEDITIONABLE);
24731             break;
24732           default:
24733             jj_la1[343] = jj_gen;
24734             jj_consume_token(-1);
24735             throw new ParseException();
24736           }
24737           break;
24738         default:
24739           jj_la1[344] = jj_gen;
24740           ;
24741         }
24742         break;
24743       default:
24744         jj_la1[345] = jj_gen;
24745         ;
24746       }
24747       jj_consume_token(TYPE);
24748       simpleNode = ObjectNameDeclaration();
24749       switch (jj_nt.kind) {
24750       case FORCE:
24751         jj_consume_token(FORCE);
24752         break;
24753       default:
24754         jj_la1[346] = jj_gen;
24755         ;
24756       }
24757       if (jj_2_63(2)) {
24758         jj_consume_token(OID);
24759         jj_consume_token(STRING_LITERAL);
24760       } else {
24761         ;
24762       }
24763       label_75:
24764       while (true) {
24765         if (jj_2_64(2)) {
24766           ;
24767         } else {
24768           break label_75;
24769         }
24770         switch (jj_nt.kind) {
24771         case AUTHID:
24772           jj_consume_token(AUTHID);
24773           switch (jj_nt.kind) {
24774           case CURRENT_USER:
24775             jj_consume_token(CURRENT_USER);
24776             break;
24777           case DEFINER:
24778             jj_consume_token(DEFINER);
24779             break;
24780           default:
24781             jj_la1[347] = jj_gen;
24782             jj_consume_token(-1);
24783             throw new ParseException();
24784           }
24785           break;
24786         case ACCESSIBLE:
24787           AccessibleByClause();
24788           break;
24789         default:
24790           jj_la1[348] = jj_gen;
24791           jj_consume_token(-1);
24792           throw new ParseException();
24793         }
24794       }
24795       switch (jj_nt.kind) {
24796       case AS:
24797       case IS:
24798       case UNDER:
24799         switch (jj_nt.kind) {
24800         case UNDER:
24801           jj_consume_token(UNDER);
24802           ObjectNameDeclaration();
24803           break;
24804         default:
24805           jj_la1[355] = jj_gen;
24806           if (jj_2_65(2)) {
24807             switch (jj_nt.kind) {
24808             case IS:
24809               jj_consume_token(IS);
24810               break;
24811             case AS:
24812               jj_consume_token(AS);
24813               break;
24814             default:
24815               jj_la1[349] = jj_gen;
24816               jj_consume_token(-1);
24817               throw new ParseException();
24818             }
24819             jj_consume_token(OBJECT);
24820           } else if (jj_2_66(2)) {
24821             switch (jj_nt.kind) {
24822             case IS:
24823               jj_consume_token(IS);
24824               break;
24825             case AS:
24826               jj_consume_token(AS);
24827               break;
24828             default:
24829               jj_la1[350] = jj_gen;
24830               jj_consume_token(-1);
24831               throw new ParseException();
24832             }
24833             jj_consume_token(OPAQUE);
24834             jj_consume_token(VARYING);
24835             jj_consume_token(24);
24836             jj_consume_token(USING);
24837             jj_consume_token(LIBRARY);
24838             switch (jj_nt.kind) {
24839             case IDENTIFIER:
24840               jj_consume_token(IDENTIFIER);
24841               break;
24842             case QUOTED_LITERAL:
24843               jj_consume_token(QUOTED_LITERAL);
24844               break;
24845             case STRING_LITERAL:
24846               StringLiteral();
24847               break;
24848             default:
24849               jj_la1[351] = jj_gen;
24850               jj_consume_token(-1);
24851               throw new ParseException();
24852             }
24853             switch (jj_nt.kind) {
24854             case 3:
24855               jj_consume_token(3);
24856               switch (jj_nt.kind) {
24857               case IDENTIFIER:
24858                 jj_consume_token(IDENTIFIER);
24859                 break;
24860               case QUOTED_LITERAL:
24861                 jj_consume_token(QUOTED_LITERAL);
24862                 break;
24863               case STRING_LITERAL:
24864                 StringLiteral();
24865                 break;
24866               default:
24867                 jj_la1[352] = jj_gen;
24868                 jj_consume_token(-1);
24869                 throw new ParseException();
24870               }
24871               break;
24872             default:
24873               jj_la1[353] = jj_gen;
24874               ;
24875             }
24876           } else if (jj_2_67(2)) {
24877             switch (jj_nt.kind) {
24878             case IS:
24879               jj_consume_token(IS);
24880               break;
24881             case AS:
24882               jj_consume_token(AS);
24883               break;
24884             default:
24885               jj_la1[354] = jj_gen;
24886               jj_consume_token(-1);
24887               throw new ParseException();
24888             }
24889             CollectionTypeName();
24890             jj_consume_token(OF);
24891             Datatype();
24892           } else {
24893             jj_consume_token(-1);
24894             throw new ParseException();
24895           }
24896         }
24897         break;
24898       default:
24899         jj_la1[356] = jj_gen;
24900         ;
24901       }
24902       if (jj_2_68(8)) {
24903         jj_consume_token(EXTERNAL);
24904         jj_consume_token(IDENTIFIER);
24905         jj_consume_token(IDENTIFIER);
24906         jj_consume_token(LANGUAGE);
24907         jj_consume_token(JAVA);
24908         jj_consume_token(USING);
24909         jj_consume_token(IDENTIFIER);
24910       } else {
24911         ;
24912       }
24913       switch (jj_nt.kind) {
24914       case WRAPPED:
24915         WrappedObject();
24916         break;
24917       default:
24918         jj_la1[357] = jj_gen;
24919         ;
24920       }
24921       switch (jj_nt.kind) {
24922       case 5:
24923         jj_consume_token(5);
24924         label_76:
24925         while (true) {
24926           switch (jj_nt.kind) {
24927           case REPLACE:
24928           case DEFINER:
24929           case CURRENT_USER:
24930           case SERIALLY_REUSABLE:
24931           case RESTRICT_REFERENCES:
24932           case EXCEPTION_INIT:
24933           case AUTONOMOUS_TRANSACTION:
24934           case LANGUAGE:
24935           case INLINE:
24936           case ADD:
24937           case AGGREGATE:
24938           case ALL:
24939           case ALTER:
24940           case AND:
24941           case ANY:
24942           case ARRAY:
24943           case AS:
24944           case ASC:
24945           case AT:
24946           case ATTRIBUTE:
24947           case AUTHID:
24948           case AVG:
24949           case BETWEEN:
24950           case BINARY_INTEGER:
24951           case BODY:
24952           case BOOLEAN:
24953           case BULK:
24954           case BY:
24955           case BYTE:
24956           case CASCADE:
24957           case CASE:
24958           case CHAR:
24959           case CHAR_BASE:
24960           case CHECK:
24961           case CLOSE:
24962           case CLUSTER:
24963           case COALESCE:
24964           case COLLECT:
24965           case COLUMN:
24966           case COMMENT:
24967           case COMMIT:
24968           case COMPRESS:
24969           case CONNECT:
24970           case CONSTANT:
24971           case CONSTRUCTOR:
24972           case CONTINUE:
24973           case CONVERT:
24974           case CREATE:
24975           case CURRENT:
24976           case CURRVAL:
24977           case CURSOR:
24978           case DATA:
24979           case DATE:
24980           case DAY:
24981           case DECLARE:
24982           case DECIMAL:
24983           case _DEFAULT:
24984           case DELETE:
24985           case DESC:
24986           case DISABLE:
24987           case DISTINCT:
24988           case DO:
24989           case DROP:
24990           case EDITIONABLE:
24991           case ELEMENT:
24992           case ELSE:
24993           case ELSIF:
24994           case ENABLE:
24995           case ESCAPE:
24996           case EXCEPT:
24997           case EXCEPTION:
24998           case EXCEPTIONS:
24999           case EXCLUSIVE:
25000           case EXECUTE:
25001           case EXISTS:
25002           case EXIT:
25003           case EXTERNAL:
25004           case EXTENDS:
25005           case EXTRACT:
25006           case FALSE:
25007           case FETCH:
25008           case FINAL:
25009           case FLOAT:
25010           case FOR:
25011           case FORALL:
25012           case FORCE:
25013           case FROM:
25014           case FUNCTION:
25015           case GLOBAL:
25016           case GOTO:
25017           case GROUP:
25018           case HASH:
25019           case HAVING:
25020           case HEAP:
25021           case HOUR:
25022           case IF:
25023           case IMMEDIATE:
25024           case IN:
25025           case INDEX:
25026           case INDICES:
25027           case INDEXTYPE:
25028           case INDICATOR:
25029           case INSERT:
25030           case INSTANTIABLE:
25031           case INTEGER:
25032           case INTERFACE:
25033           case INTERSECT:
25034           case INTERVAL:
25035           case INTO:
25036           case INVALIDATE:
25037           case IS:
25038           case ISOLATION:
25039           case JAVA:
25040           case LEVEL:
25041           case LIKE:
25042           case LIMIT:
25043           case LIMITED:
25044           case LOCK:
25045           case LONG:
25046           case LOOP:
25047           case MAP:
25048           case MAX:
25049           case MEMBER:
25050           case MERGE:
25051           case MIN:
25052           case MINUS:
25053           case MINUTE:
25054           case MLSLABEL:
25055           case MODIFY:
25056           case MOD:
25057           case MODE:
25058           case MONTH:
25059           case NATURAL:
25060           case NATURALN:
25061           case NEW:
25062           case NEXTVAL:
25063           case NO:
25064           case NOCOPY:
25065           case NONEDITIONABLE:
25066           case NOT:
25067           case NOWAIT:
25068           case NULL:
25069           case NULLIF:
25070           case NUMBER:
25071           case BFILE_BASE:
25072           case BLOB_BASE:
25073           case CLOB_BASE:
25074           case DATE_BASE:
25075           case NUMBER_BASE:
25076           case OBJECT:
25077           case OCIROWID:
25078           case OF:
25079           case OID:
25080           case ON:
25081           case OPAQUE:
25082           case OPEN:
25083           case OPERATOR:
25084           case OPTION:
25085           case OR:
25086           case ORDER:
25087           case ORGANIZATION:
25088           case OTHERS:
25089           case OUT:
25090           case OVERRIDING:
25091           case PACKAGE:
25092           case PARTITION:
25093           case PCTFREE:
25094           case PLS_INTEGER:
25095           case POSITIVE:
25096           case POSITIVEN:
25097           case PRAGMA:
25098           case PRESERVE:
25099           case PRIOR:
25100           case PROMPT:
25101           case PRIVATE:
25102           case PROCEDURE:
25103           case PUBLIC:
25104           case RAISE:
25105           case RANGE:
25106           case RAW:
25107           case REAL:
25108           case RECORD:
25109           case REF:
25110           case RELEASE:
25111           case RELIES_ON:
25112           case RENAME:
25113           case RESULT:
25114           case RETURN:
25115           case RETURNING:
25116           case REVERSE:
25117           case ROLLBACK:
25118           case ROW:
25119           case ROWS:
25120           case ROWID:
25121           case ROWNUM:
25122           case ROWTYPE:
25123           case SAVE:
25124           case SAVEPOINT:
25125           case SECOND:
25126           case SELECT:
25127           case SELF:
25128           case SEPARATE:
25129           case SET:
25130           case SHARE:
25131           case SMALLINT:
25132           case SPACE:
25133           case SQL:
25134           case SQLCODE:
25135           case SQLERRM:
25136           case START:
25137           case STATIC:
25138           case STDDEV:
25139           case SUBTYPE:
25140           case SUBSTITUTABLE:
25141           case SUCCESSFUL:
25142           case SUM:
25143           case SYNONYM:
25144           case SYSDATE:
25145           case SYS_REFCURSOR:
25146           case TABLE:
25147           case TEMPORARY:
25148           case THEN:
25149           case TIME:
25150           case TIMESTAMP:
25151           case TIMEZONE_REGION:
25152           case TIMEZONE_ABBR:
25153           case TIMEZONE_MINUTE:
25154           case TIMEZONE_HOUR:
25155           case TO:
25156           case TRANSACTION:
25157           case TRIGGER:
25158           case TRUE:
25159           case TYPE:
25160           case UI:
25161           case UNDER:
25162           case USING:
25163           case WHILE:
25164           case YES:
25165           case SHOW:
25166           case A:
25167           case UPDATE:
25168           case VARCHAR:
25169           case VARCHAR2:
25170           case DOUBLE:
25171           case DEC:
25172           case PRECISION:
25173           case INT:
25174           case NUMERIC:
25175           case SIGNTYPE:
25176           case NCHAR:
25177           case NVARCHAR2:
25178           case STRING:
25179           case UROWID:
25180           case VARRAY:
25181           case VARYING:
25182           case BFILE:
25183           case BLOB:
25184           case CLOB:
25185           case NCLOB:
25186           case YEAR:
25187           case LOCAL:
25188           case WITH:
25189           case ZONE:
25190           case CHARACTER:
25191           case AFTER:
25192           case BEFORE:
25193           case OLD:
25194           case PARENT:
25195           case ANALYZE:
25196           case ASSOCIATE:
25197           case AUDIT:
25198           case COMPOUND:
25199           case DATABASE:
25200           case CALL:
25201           case DDL:
25202           case DISASSOCIATE:
25203           case EACH:
25204           case FOLLOWS:
25205           case LOGOFF:
25206           case LOGON:
25207           case NESTED:
25208           case NOAUDIT:
25209           case SCHEMA:
25210           case SERVERERROR:
25211           case SHUTDOWN:
25212           case STARTUP:
25213           case STATEMENT:
25214           case STATISTICS:
25215           case SUSPEND:
25216           case TRUNCATE:
25217           case WRAPPED:
25218           case LIBRARY:
25219           case NAME:
25220           case STRUCT:
25221           case CONTEXT:
25222           case PARAMETERS:
25223           case LENGTH:
25224           case TDO:
25225           case MAXLEN:
25226           case CHARSETID:
25227           case CHARSETFORM:
25228           case ACCEPT:
25229           case ACCESSIBLE:
25230           case COPY:
25231           case DEFINE:
25232           case DISCONNECT:
25233           case HOST:
25234           case PRINT:
25235           case QUIT:
25236           case REMARK:
25237           case UNDEFINE:
25238           case VARIABLE:
25239           case WHENEVER:
25240           case ATTACH:
25241           case CAST:
25242           case TREAT:
25243           case TRIM:
25244           case LEFT:
25245           case RIGHT:
25246           case BOTH:
25247           case EMPTY:
25248           case MULTISET:
25249           case SUBMULTISET:
25250           case LEADING:
25251           case TRAILING:
25252           case CHAR_CS:
25253           case NCHAR_CS:
25254           case DBTIMEZONE:
25255           case SESSIONTIMEZONE:
25256           case AUTHENTICATED:
25257           case LINK:
25258           case SHARED:
25259           case DIRECTORY:
25260           case USER:
25261           case IDENTIFIER:
25262           case QUOTED_LITERAL:
25263           case SQLDATA_CLASS:
25264           case CUSTOMDATUM_CLASS:
25265           case ORADATA_CLASS:
25266           case JAVA_INTERFACE_CLASS:
25267             ;
25268             break;
25269           default:
25270             jj_la1[358] = jj_gen;
25271             break label_76;
25272           }
25273           if (jj_2_69(2)) {
25274             TypeMethod();
25275           } else {
25276             switch (jj_nt.kind) {
25277             case REPLACE:
25278             case DEFINER:
25279             case CURRENT_USER:
25280             case SERIALLY_REUSABLE:
25281             case RESTRICT_REFERENCES:
25282             case EXCEPTION_INIT:
25283             case AUTONOMOUS_TRANSACTION:
25284             case LANGUAGE:
25285             case INLINE:
25286             case ADD:
25287             case AGGREGATE:
25288             case ALL:
25289             case ALTER:
25290             case AND:
25291             case ANY:
25292             case ARRAY:
25293             case AS:
25294             case ASC:
25295             case AT:
25296             case ATTRIBUTE:
25297             case AUTHID:
25298             case AVG:
25299             case BETWEEN:
25300             case BINARY_INTEGER:
25301             case BODY:
25302             case BOOLEAN:
25303             case BULK:
25304             case BY:
25305             case BYTE:
25306             case CASCADE:
25307             case CASE:
25308             case CHAR:
25309             case CHAR_BASE:
25310             case CHECK:
25311             case CLOSE:
25312             case CLUSTER:
25313             case COALESCE:
25314             case COLLECT:
25315             case COLUMN:
25316             case COMMENT:
25317             case COMMIT:
25318             case COMPRESS:
25319             case CONNECT:
25320             case CONSTANT:
25321             case CONSTRUCTOR:
25322             case CONTINUE:
25323             case CONVERT:
25324             case CREATE:
25325             case CURRENT:
25326             case CURRVAL:
25327             case CURSOR:
25328             case DATA:
25329             case DATE:
25330             case DAY:
25331             case DECLARE:
25332             case DECIMAL:
25333             case _DEFAULT:
25334             case DELETE:
25335             case DESC:
25336             case DISABLE:
25337             case DISTINCT:
25338             case DO:
25339             case DROP:
25340             case EDITIONABLE:
25341             case ELEMENT:
25342             case ELSE:
25343             case ELSIF:
25344             case ENABLE:
25345             case ESCAPE:
25346             case EXCEPT:
25347             case EXCEPTION:
25348             case EXCEPTIONS:
25349             case EXCLUSIVE:
25350             case EXECUTE:
25351             case EXISTS:
25352             case EXIT:
25353             case EXTERNAL:
25354             case EXTENDS:
25355             case EXTRACT:
25356             case FALSE:
25357             case FETCH:
25358             case FINAL:
25359             case FLOAT:
25360             case FOR:
25361             case FORALL:
25362             case FORCE:
25363             case FROM:
25364             case FUNCTION:
25365             case GLOBAL:
25366             case GOTO:
25367             case GROUP:
25368             case HASH:
25369             case HAVING:
25370             case HEAP:
25371             case HOUR:
25372             case IF:
25373             case IMMEDIATE:
25374             case IN:
25375             case INDEX:
25376             case INDICES:
25377             case INDEXTYPE:
25378             case INDICATOR:
25379             case INSERT:
25380             case INSTANTIABLE:
25381             case INTEGER:
25382             case INTERFACE:
25383             case INTERSECT:
25384             case INTERVAL:
25385             case INTO:
25386             case INVALIDATE:
25387             case IS:
25388             case ISOLATION:
25389             case JAVA:
25390             case LEVEL:
25391             case LIKE:
25392             case LIMIT:
25393             case LIMITED:
25394             case LOCK:
25395             case LONG:
25396             case LOOP:
25397             case MAP:
25398             case MAX:
25399             case MEMBER:
25400             case MERGE:
25401             case MIN:
25402             case MINUS:
25403             case MINUTE:
25404             case MLSLABEL:
25405             case MODIFY:
25406             case MOD:
25407             case MODE:
25408             case MONTH:
25409             case NATURAL:
25410             case NATURALN:
25411             case NEW:
25412             case NEXTVAL:
25413             case NO:
25414             case NOCOPY:
25415             case NONEDITIONABLE:
25416             case NOT:
25417             case NOWAIT:
25418             case NULL:
25419             case NULLIF:
25420             case NUMBER:
25421             case BFILE_BASE:
25422             case BLOB_BASE:
25423             case CLOB_BASE:
25424             case DATE_BASE:
25425             case NUMBER_BASE:
25426             case OBJECT:
25427             case OCIROWID:
25428             case OF:
25429             case OID:
25430             case ON:
25431             case OPAQUE:
25432             case OPEN:
25433             case OPERATOR:
25434             case OPTION:
25435             case OR:
25436             case ORDER:
25437             case ORGANIZATION:
25438             case OTHERS:
25439             case OUT:
25440             case OVERRIDING:
25441             case PACKAGE:
25442             case PARTITION:
25443             case PCTFREE:
25444             case PLS_INTEGER:
25445             case POSITIVE:
25446             case POSITIVEN:
25447             case PRESERVE:
25448             case PRIOR:
25449             case PROMPT:
25450             case PRIVATE:
25451             case PROCEDURE:
25452             case PUBLIC:
25453             case RAISE:
25454             case RANGE:
25455             case RAW:
25456             case REAL:
25457             case RECORD:
25458             case REF:
25459             case RELEASE:
25460             case RELIES_ON:
25461             case RENAME:
25462             case RESULT:
25463             case RETURN:
25464             case RETURNING:
25465             case REVERSE:
25466             case ROLLBACK:
25467             case ROW:
25468             case ROWS:
25469             case ROWID:
25470             case ROWNUM:
25471             case ROWTYPE:
25472             case SAVE:
25473             case SAVEPOINT:
25474             case SECOND:
25475             case SELECT:
25476             case SELF:
25477             case SEPARATE:
25478             case SET:
25479             case SHARE:
25480             case SMALLINT:
25481             case SPACE:
25482             case SQL:
25483             case SQLCODE:
25484             case SQLERRM:
25485             case START:
25486             case STATIC:
25487             case STDDEV:
25488             case SUBTYPE:
25489             case SUBSTITUTABLE:
25490             case SUCCESSFUL:
25491             case SUM:
25492             case SYNONYM:
25493             case SYSDATE:
25494             case SYS_REFCURSOR:
25495             case TABLE:
25496             case TEMPORARY:
25497             case THEN:
25498             case TIME:
25499             case TIMESTAMP:
25500             case TIMEZONE_REGION:
25501             case TIMEZONE_ABBR:
25502             case TIMEZONE_MINUTE:
25503             case TIMEZONE_HOUR:
25504             case TO:
25505             case TRANSACTION:
25506             case TRIGGER:
25507             case TRUE:
25508             case TYPE:
25509             case UI:
25510             case UNDER:
25511             case USING:
25512             case WHILE:
25513             case YES:
25514             case SHOW:
25515             case A:
25516             case UPDATE:
25517             case VARCHAR:
25518             case VARCHAR2:
25519             case DOUBLE:
25520             case DEC:
25521             case PRECISION:
25522             case INT:
25523             case NUMERIC:
25524             case SIGNTYPE:
25525             case NCHAR:
25526             case NVARCHAR2:
25527             case STRING:
25528             case UROWID:
25529             case VARRAY:
25530             case VARYING:
25531             case BFILE:
25532             case BLOB:
25533             case CLOB:
25534             case NCLOB:
25535             case YEAR:
25536             case LOCAL:
25537             case WITH:
25538             case ZONE:
25539             case CHARACTER:
25540             case AFTER:
25541             case BEFORE:
25542             case OLD:
25543             case PARENT:
25544             case ANALYZE:
25545             case ASSOCIATE:
25546             case AUDIT:
25547             case COMPOUND:
25548             case DATABASE:
25549             case CALL:
25550             case DDL:
25551             case DISASSOCIATE:
25552             case EACH:
25553             case FOLLOWS:
25554             case LOGOFF:
25555             case LOGON:
25556             case NESTED:
25557             case NOAUDIT:
25558             case SCHEMA:
25559             case SERVERERROR:
25560             case SHUTDOWN:
25561             case STARTUP:
25562             case STATEMENT:
25563             case STATISTICS:
25564             case SUSPEND:
25565             case TRUNCATE:
25566             case WRAPPED:
25567             case LIBRARY:
25568             case NAME:
25569             case STRUCT:
25570             case CONTEXT:
25571             case PARAMETERS:
25572             case LENGTH:
25573             case TDO:
25574             case MAXLEN:
25575             case CHARSETID:
25576             case CHARSETFORM:
25577             case ACCEPT:
25578             case ACCESSIBLE:
25579             case COPY:
25580             case DEFINE:
25581             case DISCONNECT:
25582             case HOST:
25583             case PRINT:
25584             case QUIT:
25585             case REMARK:
25586             case UNDEFINE:
25587             case VARIABLE:
25588             case WHENEVER:
25589             case ATTACH:
25590             case CAST:
25591             case TREAT:
25592             case TRIM:
25593             case LEFT:
25594             case RIGHT:
25595             case BOTH:
25596             case EMPTY:
25597             case MULTISET:
25598             case SUBMULTISET:
25599             case LEADING:
25600             case TRAILING:
25601             case CHAR_CS:
25602             case NCHAR_CS:
25603             case DBTIMEZONE:
25604             case SESSIONTIMEZONE:
25605             case AUTHENTICATED:
25606             case LINK:
25607             case SHARED:
25608             case DIRECTORY:
25609             case USER:
25610             case IDENTIFIER:
25611             case QUOTED_LITERAL:
25612             case SQLDATA_CLASS:
25613             case CUSTOMDATUM_CLASS:
25614             case ORADATA_CLASS:
25615             case JAVA_INTERFACE_CLASS:
25616               AttributeDeclaration();
25617               break;
25618             case PRAGMA:
25619               PragmaClause();
25620               break;
25621             default:
25622               jj_la1[359] = jj_gen;
25623               jj_consume_token(-1);
25624               throw new ParseException();
25625             }
25626           }
25627         }
25628         label_77:
25629         while (true) {
25630           switch (jj_nt.kind) {
25631           case 6:
25632             ;
25633             break;
25634           default:
25635             jj_la1[360] = jj_gen;
25636             break label_77;
25637           }
25638           jj_consume_token(6);
25639           switch (jj_nt.kind) {
25640           case CONSTRUCTOR:
25641           case FINAL:
25642           case INSTANTIABLE:
25643           case MAP:
25644           case MEMBER:
25645           case NOT:
25646           case ORDER:
25647           case OVERRIDING:
25648           case STATIC:
25649             TypeMethod();
25650             break;
25651           default:
25652             jj_la1[361] = jj_gen;
25653             if (jj_2_70(2)) {
25654               AttributeDeclaration();
25655             } else {
25656               switch (jj_nt.kind) {
25657               case PRAGMA:
25658                 PragmaClause();
25659                 break;
25660               default:
25661                 jj_la1[362] = jj_gen;
25662                 jj_consume_token(-1);
25663                 throw new ParseException();
25664               }
25665             }
25666           }
25667         }
25668         jj_consume_token(7);
25669         break;
25670       default:
25671         jj_la1[363] = jj_gen;
25672         ;
25673       }
25674       label_78:
25675       while (true) {
25676         switch (jj_nt.kind) {
25677         case FINAL:
25678         case INSTANTIABLE:
25679         case NOT:
25680         case NULL:
25681           ;
25682           break;
25683         default:
25684           jj_la1[364] = jj_gen;
25685           break label_78;
25686         }
25687         switch (jj_nt.kind) {
25688         case NOT:
25689           jj_consume_token(NOT);
25690           break;
25691         default:
25692           jj_la1[365] = jj_gen;
25693           ;
25694         }
25695         switch (jj_nt.kind) {
25696         case FINAL:
25697           jj_consume_token(FINAL);
25698           break;
25699         case INSTANTIABLE:
25700           jj_consume_token(INSTANTIABLE);
25701           break;
25702         case NULL:
25703           jj_consume_token(NULL);
25704           break;
25705         default:
25706           jj_la1[366] = jj_gen;
25707           jj_consume_token(-1);
25708           throw new ParseException();
25709         }
25710       }
25711       label_79:
25712       while (true) {
25713         switch (jj_nt.kind) {
25714         case ALTER:
25715           ;
25716           break;
25717         default:
25718           jj_la1[367] = jj_gen;
25719           break label_79;
25720         }
25721         AlterTypeSpec();
25722       }
25723       switch (jj_nt.kind) {
25724       case 1:
25725       case 4:
25726         switch (jj_nt.kind) {
25727         case 4:
25728           jj_consume_token(4);
25729           break;
25730         case 1:
25731           jj_consume_token(1);
25732           break;
25733         default:
25734           jj_la1[368] = jj_gen;
25735           jj_consume_token(-1);
25736           throw new ParseException();
25737         }
25738         label_80:
25739         while (true) {
25740           switch (jj_nt.kind) {
25741           case ALTER:
25742             ;
25743             break;
25744           default:
25745             jj_la1[369] = jj_gen;
25746             break label_80;
25747           }
25748           AlterTypeSpec();
25749           switch (jj_nt.kind) {
25750           case 1:
25751             jj_consume_token(1);
25752             break;
25753           case 4:
25754             jj_consume_token(4);
25755             break;
25756           default:
25757             jj_la1[370] = jj_gen;
25758             jj_consume_token(-1);
25759             throw new ParseException();
25760           }
25761         }
25762         break;
25763       default:
25764         jj_la1[371] = jj_gen;
25765         ;
25766       }
25767         jjtree.closeNodeScope(jjtn000, true);
25768         jjtc000 = false;
25769         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
25770     } catch (Throwable jjte000) {
25771           if (jjtc000) {
25772             jjtree.clearNodeScope(jjtn000);
25773             jjtc000 = false;
25774           } else {
25775             jjtree.popNode();
25776           }
25777           if (jjte000 instanceof RuntimeException) {
25778             {if (true) throw (RuntimeException)jjte000;}
25779           }
25780           if (jjte000 instanceof ParseException) {
25781             {if (true) throw (ParseException)jjte000;}
25782           }
25783           {if (true) throw (Error)jjte000;}
25784     } finally {
25785           if (jjtc000) {
25786             jjtree.closeNodeScope(jjtn000, true);
25787           }
25788     }
25789     throw new Error("Missing return statement in function");
25790   }
25791 
25792   final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25793  /*@bgen(jjtree) AlterTypeSpec */
25794  ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25795  boolean jjtc000 = true;
25796  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25797     try {
25798       jj_consume_token(ALTER);
25799       jj_consume_token(TYPE);
25800       simpleNode = QualifiedName();
25801       label_81:
25802       while (true) {
25803         switch (jj_nt.kind) {
25804         case 6:
25805         case ADD:
25806         case DROP:
25807         case MODIFY:
25808           ;
25809           break;
25810         default:
25811           jj_la1[372] = jj_gen;
25812           break label_81;
25813         }
25814         switch (jj_nt.kind) {
25815         case 6:
25816         case ADD:
25817         case MODIFY:
25818           switch (jj_nt.kind) {
25819           case 6:
25820             jj_consume_token(6);
25821             break;
25822           default:
25823             jj_la1[373] = jj_gen;
25824             ;
25825           }
25826           switch (jj_nt.kind) {
25827           case ADD:
25828             jj_consume_token(ADD);
25829             break;
25830           case MODIFY:
25831             jj_consume_token(MODIFY);
25832             break;
25833           default:
25834             jj_la1[374] = jj_gen;
25835             jj_consume_token(-1);
25836             throw new ParseException();
25837           }
25838           label_82:
25839           while (true) {
25840             switch (jj_nt.kind) {
25841             case CONSTRUCTOR:
25842             case FINAL:
25843             case INSTANTIABLE:
25844             case MAP:
25845             case MEMBER:
25846             case NOT:
25847             case ORDER:
25848             case OVERRIDING:
25849             case STATIC:
25850               TypeMethod();
25851               break;
25852             case ATTRIBUTE:
25853               jj_consume_token(ATTRIBUTE);
25854               label_83:
25855               while (true) {
25856                 switch (jj_nt.kind) {
25857                 case 5:
25858                   ;
25859                   break;
25860                 default:
25861                   jj_la1[375] = jj_gen;
25862                   break label_83;
25863                 }
25864                 jj_consume_token(5);
25865               }
25866               AttributeDeclaration();
25867               label_84:
25868               while (true) {
25869                 switch (jj_nt.kind) {
25870                 case 6:
25871                   ;
25872                   break;
25873                 default:
25874                   jj_la1[376] = jj_gen;
25875                   break label_84;
25876                 }
25877                 jj_consume_token(6);
25878                 AttributeDeclaration();
25879               }
25880               label_85:
25881               while (true) {
25882                 switch (jj_nt.kind) {
25883                 case 7:
25884                   ;
25885                   break;
25886                 default:
25887                   jj_la1[377] = jj_gen;
25888                   break label_85;
25889                 }
25890                 jj_consume_token(7);
25891               }
25892               break;
25893             case LIMIT:
25894               jj_consume_token(LIMIT);
25895               NumericLiteral();
25896               break;
25897             case ELEMENT:
25898               jj_consume_token(ELEMENT);
25899               jj_consume_token(TYPE);
25900               Datatype();
25901               break;
25902             default:
25903               jj_la1[378] = jj_gen;
25904               jj_consume_token(-1);
25905               throw new ParseException();
25906             }
25907             switch (jj_nt.kind) {
25908             case ATTRIBUTE:
25909             case CONSTRUCTOR:
25910             case ELEMENT:
25911             case FINAL:
25912             case INSTANTIABLE:
25913             case LIMIT:
25914             case MAP:
25915             case MEMBER:
25916             case NOT:
25917             case ORDER:
25918             case OVERRIDING:
25919             case STATIC:
25920               ;
25921               break;
25922             default:
25923               jj_la1[379] = jj_gen;
25924               break label_82;
25925             }
25926           }
25927           break;
25928         case DROP:
25929           jj_consume_token(DROP);
25930           label_86:
25931           while (true) {
25932             switch (jj_nt.kind) {
25933             case ATTRIBUTE:
25934               jj_consume_token(ATTRIBUTE);
25935               label_87:
25936               while (true) {
25937                 switch (jj_nt.kind) {
25938                 case 5:
25939                   ;
25940                   break;
25941                 default:
25942                   jj_la1[380] = jj_gen;
25943                   break label_87;
25944                 }
25945                 jj_consume_token(5);
25946               }
25947               Attribute();
25948               label_88:
25949               while (true) {
25950                 switch (jj_nt.kind) {
25951                 case 6:
25952                   ;
25953                   break;
25954                 default:
25955                   jj_la1[381] = jj_gen;
25956                   break label_88;
25957                 }
25958                 jj_consume_token(6);
25959                 Attribute();
25960               }
25961               label_89:
25962               while (true) {
25963                 switch (jj_nt.kind) {
25964                 case 7:
25965                   ;
25966                   break;
25967                 default:
25968                   jj_la1[382] = jj_gen;
25969                   break label_89;
25970                 }
25971                 jj_consume_token(7);
25972               }
25973               break;
25974             case CONSTRUCTOR:
25975             case FINAL:
25976             case INSTANTIABLE:
25977             case MAP:
25978             case MEMBER:
25979             case NOT:
25980             case ORDER:
25981             case OVERRIDING:
25982             case STATIC:
25983               TypeMethod();
25984               break;
25985             default:
25986               jj_la1[383] = jj_gen;
25987               jj_consume_token(-1);
25988               throw new ParseException();
25989             }
25990             switch (jj_nt.kind) {
25991             case ATTRIBUTE:
25992             case CONSTRUCTOR:
25993             case FINAL:
25994             case INSTANTIABLE:
25995             case MAP:
25996             case MEMBER:
25997             case NOT:
25998             case ORDER:
25999             case OVERRIDING:
26000             case STATIC:
26001               ;
26002               break;
26003             default:
26004               jj_la1[384] = jj_gen;
26005               break label_86;
26006             }
26007           }
26008           break;
26009         default:
26010           jj_la1[385] = jj_gen;
26011           jj_consume_token(-1);
26012           throw new ParseException();
26013         }
26014       }
26015       switch (jj_nt.kind) {
26016       case REPLACE:
26017         jj_consume_token(REPLACE);
26018         label_90:
26019         while (true) {
26020           if (jj_2_71(2)) {
26021             ;
26022           } else {
26023             break label_90;
26024           }
26025           switch (jj_nt.kind) {
26026           case AUTHID:
26027             jj_consume_token(AUTHID);
26028             switch (jj_nt.kind) {
26029             case CURRENT_USER:
26030               jj_consume_token(CURRENT_USER);
26031               break;
26032             case DEFINER:
26033               jj_consume_token(DEFINER);
26034               break;
26035             default:
26036               jj_la1[386] = jj_gen;
26037               jj_consume_token(-1);
26038               throw new ParseException();
26039             }
26040             break;
26041           case ACCESSIBLE:
26042             AccessibleByClause();
26043             break;
26044           default:
26045             jj_la1[387] = jj_gen;
26046             jj_consume_token(-1);
26047             throw new ParseException();
26048           }
26049         }
26050         switch (jj_nt.kind) {
26051         case IS:
26052           jj_consume_token(IS);
26053           break;
26054         case AS:
26055           jj_consume_token(AS);
26056           break;
26057         default:
26058           jj_la1[388] = jj_gen;
26059           jj_consume_token(-1);
26060           throw new ParseException();
26061         }
26062         jj_consume_token(OBJECT);
26063         jj_consume_token(5);
26064         if (jj_2_72(2)) {
26065           TypeMethod();
26066         } else {
26067           switch (jj_nt.kind) {
26068           case REPLACE:
26069           case DEFINER:
26070           case CURRENT_USER:
26071           case SERIALLY_REUSABLE:
26072           case RESTRICT_REFERENCES:
26073           case EXCEPTION_INIT:
26074           case AUTONOMOUS_TRANSACTION:
26075           case LANGUAGE:
26076           case INLINE:
26077           case ADD:
26078           case AGGREGATE:
26079           case ALL:
26080           case ALTER:
26081           case AND:
26082           case ANY:
26083           case ARRAY:
26084           case AS:
26085           case ASC:
26086           case AT:
26087           case ATTRIBUTE:
26088           case AUTHID:
26089           case AVG:
26090           case BETWEEN:
26091           case BINARY_INTEGER:
26092           case BODY:
26093           case BOOLEAN:
26094           case BULK:
26095           case BY:
26096           case BYTE:
26097           case CASCADE:
26098           case CASE:
26099           case CHAR:
26100           case CHAR_BASE:
26101           case CHECK:
26102           case CLOSE:
26103           case CLUSTER:
26104           case COALESCE:
26105           case COLLECT:
26106           case COLUMN:
26107           case COMMENT:
26108           case COMMIT:
26109           case COMPRESS:
26110           case CONNECT:
26111           case CONSTANT:
26112           case CONSTRUCTOR:
26113           case CONTINUE:
26114           case CONVERT:
26115           case CREATE:
26116           case CURRENT:
26117           case CURRVAL:
26118           case CURSOR:
26119           case DATA:
26120           case DATE:
26121           case DAY:
26122           case DECLARE:
26123           case DECIMAL:
26124           case _DEFAULT:
26125           case DELETE:
26126           case DESC:
26127           case DISABLE:
26128           case DISTINCT:
26129           case DO:
26130           case DROP:
26131           case EDITIONABLE:
26132           case ELEMENT:
26133           case ELSE:
26134           case ELSIF:
26135           case ENABLE:
26136           case ESCAPE:
26137           case EXCEPT:
26138           case EXCEPTION:
26139           case EXCEPTIONS:
26140           case EXCLUSIVE:
26141           case EXECUTE:
26142           case EXISTS:
26143           case EXIT:
26144           case EXTERNAL:
26145           case EXTENDS:
26146           case EXTRACT:
26147           case FALSE:
26148           case FETCH:
26149           case FINAL:
26150           case FLOAT:
26151           case FOR:
26152           case FORALL:
26153           case FORCE:
26154           case FROM:
26155           case FUNCTION:
26156           case GLOBAL:
26157           case GOTO:
26158           case GROUP:
26159           case HASH:
26160           case HAVING:
26161           case HEAP:
26162           case HOUR:
26163           case IF:
26164           case IMMEDIATE:
26165           case IN:
26166           case INDEX:
26167           case INDICES:
26168           case INDEXTYPE:
26169           case INDICATOR:
26170           case INSERT:
26171           case INSTANTIABLE:
26172           case INTEGER:
26173           case INTERFACE:
26174           case INTERSECT:
26175           case INTERVAL:
26176           case INTO:
26177           case INVALIDATE:
26178           case IS:
26179           case ISOLATION:
26180           case JAVA:
26181           case LEVEL:
26182           case LIKE:
26183           case LIMIT:
26184           case LIMITED:
26185           case LOCK:
26186           case LONG:
26187           case LOOP:
26188           case MAP:
26189           case MAX:
26190           case MEMBER:
26191           case MERGE:
26192           case MIN:
26193           case MINUS:
26194           case MINUTE:
26195           case MLSLABEL:
26196           case MODIFY:
26197           case MOD:
26198           case MODE:
26199           case MONTH:
26200           case NATURAL:
26201           case NATURALN:
26202           case NEW:
26203           case NEXTVAL:
26204           case NO:
26205           case NOCOPY:
26206           case NONEDITIONABLE:
26207           case NOT:
26208           case NOWAIT:
26209           case NULL:
26210           case NULLIF:
26211           case NUMBER:
26212           case BFILE_BASE:
26213           case BLOB_BASE:
26214           case CLOB_BASE:
26215           case DATE_BASE:
26216           case NUMBER_BASE:
26217           case OBJECT:
26218           case OCIROWID:
26219           case OF:
26220           case OID:
26221           case ON:
26222           case OPAQUE:
26223           case OPEN:
26224           case OPERATOR:
26225           case OPTION:
26226           case OR:
26227           case ORDER:
26228           case ORGANIZATION:
26229           case OTHERS:
26230           case OUT:
26231           case OVERRIDING:
26232           case PACKAGE:
26233           case PARTITION:
26234           case PCTFREE:
26235           case PLS_INTEGER:
26236           case POSITIVE:
26237           case POSITIVEN:
26238           case PRESERVE:
26239           case PRIOR:
26240           case PROMPT:
26241           case PRIVATE:
26242           case PROCEDURE:
26243           case PUBLIC:
26244           case RAISE:
26245           case RANGE:
26246           case RAW:
26247           case REAL:
26248           case RECORD:
26249           case REF:
26250           case RELEASE:
26251           case RELIES_ON:
26252           case RENAME:
26253           case RESULT:
26254           case RETURN:
26255           case RETURNING:
26256           case REVERSE:
26257           case ROLLBACK:
26258           case ROW:
26259           case ROWS:
26260           case ROWID:
26261           case ROWNUM:
26262           case ROWTYPE:
26263           case SAVE:
26264           case SAVEPOINT:
26265           case SECOND:
26266           case SELECT:
26267           case SELF:
26268           case SEPARATE:
26269           case SET:
26270           case SHARE:
26271           case SMALLINT:
26272           case SPACE:
26273           case SQL:
26274           case SQLCODE:
26275           case SQLERRM:
26276           case START:
26277           case STATIC:
26278           case STDDEV:
26279           case SUBTYPE:
26280           case SUBSTITUTABLE:
26281           case SUCCESSFUL:
26282           case SUM:
26283           case SYNONYM:
26284           case SYSDATE:
26285           case SYS_REFCURSOR:
26286           case TABLE:
26287           case TEMPORARY:
26288           case THEN:
26289           case TIME:
26290           case TIMESTAMP:
26291           case TIMEZONE_REGION:
26292           case TIMEZONE_ABBR:
26293           case TIMEZONE_MINUTE:
26294           case TIMEZONE_HOUR:
26295           case TO:
26296           case TRANSACTION:
26297           case TRIGGER:
26298           case TRUE:
26299           case TYPE:
26300           case UI:
26301           case UNDER:
26302           case USING:
26303           case WHILE:
26304           case YES:
26305           case SHOW:
26306           case A:
26307           case UPDATE:
26308           case VARCHAR:
26309           case VARCHAR2:
26310           case DOUBLE:
26311           case DEC:
26312           case PRECISION:
26313           case INT:
26314           case NUMERIC:
26315           case SIGNTYPE:
26316           case NCHAR:
26317           case NVARCHAR2:
26318           case STRING:
26319           case UROWID:
26320           case VARRAY:
26321           case VARYING:
26322           case BFILE:
26323           case BLOB:
26324           case CLOB:
26325           case NCLOB:
26326           case YEAR:
26327           case LOCAL:
26328           case WITH:
26329           case ZONE:
26330           case CHARACTER:
26331           case AFTER:
26332           case BEFORE:
26333           case OLD:
26334           case PARENT:
26335           case ANALYZE:
26336           case ASSOCIATE:
26337           case AUDIT:
26338           case COMPOUND:
26339           case DATABASE:
26340           case CALL:
26341           case DDL:
26342           case DISASSOCIATE:
26343           case EACH:
26344           case FOLLOWS:
26345           case LOGOFF:
26346           case LOGON:
26347           case NESTED:
26348           case NOAUDIT:
26349           case SCHEMA:
26350           case SERVERERROR:
26351           case SHUTDOWN:
26352           case STARTUP:
26353           case STATEMENT:
26354           case STATISTICS:
26355           case SUSPEND:
26356           case TRUNCATE:
26357           case WRAPPED:
26358           case LIBRARY:
26359           case NAME:
26360           case STRUCT:
26361           case CONTEXT:
26362           case PARAMETERS:
26363           case LENGTH:
26364           case TDO:
26365           case MAXLEN:
26366           case CHARSETID:
26367           case CHARSETFORM:
26368           case ACCEPT:
26369           case ACCESSIBLE:
26370           case COPY:
26371           case DEFINE:
26372           case DISCONNECT:
26373           case HOST:
26374           case PRINT:
26375           case QUIT:
26376           case REMARK:
26377           case UNDEFINE:
26378           case VARIABLE:
26379           case WHENEVER:
26380           case ATTACH:
26381           case CAST:
26382           case TREAT:
26383           case TRIM:
26384           case LEFT:
26385           case RIGHT:
26386           case BOTH:
26387           case EMPTY:
26388           case MULTISET:
26389           case SUBMULTISET:
26390           case LEADING:
26391           case TRAILING:
26392           case CHAR_CS:
26393           case NCHAR_CS:
26394           case DBTIMEZONE:
26395           case SESSIONTIMEZONE:
26396           case AUTHENTICATED:
26397           case LINK:
26398           case SHARED:
26399           case DIRECTORY:
26400           case USER:
26401           case IDENTIFIER:
26402           case QUOTED_LITERAL:
26403           case SQLDATA_CLASS:
26404           case CUSTOMDATUM_CLASS:
26405           case ORADATA_CLASS:
26406           case JAVA_INTERFACE_CLASS:
26407             AttributeDeclaration();
26408             break;
26409           default:
26410             jj_la1[389] = jj_gen;
26411             jj_consume_token(-1);
26412             throw new ParseException();
26413           }
26414         }
26415         label_91:
26416         while (true) {
26417           switch (jj_nt.kind) {
26418           case 6:
26419             ;
26420             break;
26421           default:
26422             jj_la1[390] = jj_gen;
26423             break label_91;
26424           }
26425           jj_consume_token(6);
26426           if (jj_2_73(2)) {
26427             TypeMethod();
26428           } else {
26429             switch (jj_nt.kind) {
26430             case REPLACE:
26431             case DEFINER:
26432             case CURRENT_USER:
26433             case SERIALLY_REUSABLE:
26434             case RESTRICT_REFERENCES:
26435             case EXCEPTION_INIT:
26436             case AUTONOMOUS_TRANSACTION:
26437             case LANGUAGE:
26438             case INLINE:
26439             case ADD:
26440             case AGGREGATE:
26441             case ALL:
26442             case ALTER:
26443             case AND:
26444             case ANY:
26445             case ARRAY:
26446             case AS:
26447             case ASC:
26448             case AT:
26449             case ATTRIBUTE:
26450             case AUTHID:
26451             case AVG:
26452             case BETWEEN:
26453             case BINARY_INTEGER:
26454             case BODY:
26455             case BOOLEAN:
26456             case BULK:
26457             case BY:
26458             case BYTE:
26459             case CASCADE:
26460             case CASE:
26461             case CHAR:
26462             case CHAR_BASE:
26463             case CHECK:
26464             case CLOSE:
26465             case CLUSTER:
26466             case COALESCE:
26467             case COLLECT:
26468             case COLUMN:
26469             case COMMENT:
26470             case COMMIT:
26471             case COMPRESS:
26472             case CONNECT:
26473             case CONSTANT:
26474             case CONSTRUCTOR:
26475             case CONTINUE:
26476             case CONVERT:
26477             case CREATE:
26478             case CURRENT:
26479             case CURRVAL:
26480             case CURSOR:
26481             case DATA:
26482             case DATE:
26483             case DAY:
26484             case DECLARE:
26485             case DECIMAL:
26486             case _DEFAULT:
26487             case DELETE:
26488             case DESC:
26489             case DISABLE:
26490             case DISTINCT:
26491             case DO:
26492             case DROP:
26493             case EDITIONABLE:
26494             case ELEMENT:
26495             case ELSE:
26496             case ELSIF:
26497             case ENABLE:
26498             case ESCAPE:
26499             case EXCEPT:
26500             case EXCEPTION:
26501             case EXCEPTIONS:
26502             case EXCLUSIVE:
26503             case EXECUTE:
26504             case EXISTS:
26505             case EXIT:
26506             case EXTERNAL:
26507             case EXTENDS:
26508             case EXTRACT:
26509             case FALSE:
26510             case FETCH:
26511             case FINAL:
26512             case FLOAT:
26513             case FOR:
26514             case FORALL:
26515             case FORCE:
26516             case FROM:
26517             case FUNCTION:
26518             case GLOBAL:
26519             case GOTO:
26520             case GROUP:
26521             case HASH:
26522             case HAVING:
26523             case HEAP:
26524             case HOUR:
26525             case IF:
26526             case IMMEDIATE:
26527             case IN:
26528             case INDEX:
26529             case INDICES:
26530             case INDEXTYPE:
26531             case INDICATOR:
26532             case INSERT:
26533             case INSTANTIABLE:
26534             case INTEGER:
26535             case INTERFACE:
26536             case INTERSECT:
26537             case INTERVAL:
26538             case INTO:
26539             case INVALIDATE:
26540             case IS:
26541             case ISOLATION:
26542             case JAVA:
26543             case LEVEL:
26544             case LIKE:
26545             case LIMIT:
26546             case LIMITED:
26547             case LOCK:
26548             case LONG:
26549             case LOOP:
26550             case MAP:
26551             case MAX:
26552             case MEMBER:
26553             case MERGE:
26554             case MIN:
26555             case MINUS:
26556             case MINUTE:
26557             case MLSLABEL:
26558             case MODIFY:
26559             case MOD:
26560             case MODE:
26561             case MONTH:
26562             case NATURAL:
26563             case NATURALN:
26564             case NEW:
26565             case NEXTVAL:
26566             case NO:
26567             case NOCOPY:
26568             case NONEDITIONABLE:
26569             case NOT:
26570             case NOWAIT:
26571             case NULL:
26572             case NULLIF:
26573             case NUMBER:
26574             case BFILE_BASE:
26575             case BLOB_BASE:
26576             case CLOB_BASE:
26577             case DATE_BASE:
26578             case NUMBER_BASE:
26579             case OBJECT:
26580             case OCIROWID:
26581             case OF:
26582             case OID:
26583             case ON:
26584             case OPAQUE:
26585             case OPEN:
26586             case OPERATOR:
26587             case OPTION:
26588             case OR:
26589             case ORDER:
26590             case ORGANIZATION:
26591             case OTHERS:
26592             case OUT:
26593             case OVERRIDING:
26594             case PACKAGE:
26595             case PARTITION:
26596             case PCTFREE:
26597             case PLS_INTEGER:
26598             case POSITIVE:
26599             case POSITIVEN:
26600             case PRESERVE:
26601             case PRIOR:
26602             case PROMPT:
26603             case PRIVATE:
26604             case PROCEDURE:
26605             case PUBLIC:
26606             case RAISE:
26607             case RANGE:
26608             case RAW:
26609             case REAL:
26610             case RECORD:
26611             case REF:
26612             case RELEASE:
26613             case RELIES_ON:
26614             case RENAME:
26615             case RESULT:
26616             case RETURN:
26617             case RETURNING:
26618             case REVERSE:
26619             case ROLLBACK:
26620             case ROW:
26621             case ROWS:
26622             case ROWID:
26623             case ROWNUM:
26624             case ROWTYPE:
26625             case SAVE:
26626             case SAVEPOINT:
26627             case SECOND:
26628             case SELECT:
26629             case SELF:
26630             case SEPARATE:
26631             case SET:
26632             case SHARE:
26633             case SMALLINT:
26634             case SPACE:
26635             case SQL:
26636             case SQLCODE:
26637             case SQLERRM:
26638             case START:
26639             case STATIC:
26640             case STDDEV:
26641             case SUBTYPE:
26642             case SUBSTITUTABLE:
26643             case SUCCESSFUL:
26644             case SUM:
26645             case SYNONYM:
26646             case SYSDATE:
26647             case SYS_REFCURSOR:
26648             case TABLE:
26649             case TEMPORARY:
26650             case THEN:
26651             case TIME:
26652             case TIMESTAMP:
26653             case TIMEZONE_REGION:
26654             case TIMEZONE_ABBR:
26655             case TIMEZONE_MINUTE:
26656             case TIMEZONE_HOUR:
26657             case TO:
26658             case TRANSACTION:
26659             case TRIGGER:
26660             case TRUE:
26661             case TYPE:
26662             case UI:
26663             case UNDER:
26664             case USING:
26665             case WHILE:
26666             case YES:
26667             case SHOW:
26668             case A:
26669             case UPDATE:
26670             case VARCHAR:
26671             case VARCHAR2:
26672             case DOUBLE:
26673             case DEC:
26674             case PRECISION:
26675             case INT:
26676             case NUMERIC:
26677             case SIGNTYPE:
26678             case NCHAR:
26679             case NVARCHAR2:
26680             case STRING:
26681             case UROWID:
26682             case VARRAY:
26683             case VARYING:
26684             case BFILE:
26685             case BLOB:
26686             case CLOB:
26687             case NCLOB:
26688             case YEAR:
26689             case LOCAL:
26690             case WITH:
26691             case ZONE:
26692             case CHARACTER:
26693             case AFTER:
26694             case BEFORE:
26695             case OLD:
26696             case PARENT:
26697             case ANALYZE:
26698             case ASSOCIATE:
26699             case AUDIT:
26700             case COMPOUND:
26701             case DATABASE:
26702             case CALL:
26703             case DDL:
26704             case DISASSOCIATE:
26705             case EACH:
26706             case FOLLOWS:
26707             case LOGOFF:
26708             case LOGON:
26709             case NESTED:
26710             case NOAUDIT:
26711             case SCHEMA:
26712             case SERVERERROR:
26713             case SHUTDOWN:
26714             case STARTUP:
26715             case STATEMENT:
26716             case STATISTICS:
26717             case SUSPEND:
26718             case TRUNCATE:
26719             case WRAPPED:
26720             case LIBRARY:
26721             case NAME:
26722             case STRUCT:
26723             case CONTEXT:
26724             case PARAMETERS:
26725             case LENGTH:
26726             case TDO:
26727             case MAXLEN:
26728             case CHARSETID:
26729             case CHARSETFORM:
26730             case ACCEPT:
26731             case ACCESSIBLE:
26732             case COPY:
26733             case DEFINE:
26734             case DISCONNECT:
26735             case HOST:
26736             case PRINT:
26737             case QUIT:
26738             case REMARK:
26739             case UNDEFINE:
26740             case VARIABLE:
26741             case WHENEVER:
26742             case ATTACH:
26743             case CAST:
26744             case TREAT:
26745             case TRIM:
26746             case LEFT:
26747             case RIGHT:
26748             case BOTH:
26749             case EMPTY:
26750             case MULTISET:
26751             case SUBMULTISET:
26752             case LEADING:
26753             case TRAILING:
26754             case CHAR_CS:
26755             case NCHAR_CS:
26756             case DBTIMEZONE:
26757             case SESSIONTIMEZONE:
26758             case AUTHENTICATED:
26759             case LINK:
26760             case SHARED:
26761             case DIRECTORY:
26762             case USER:
26763             case IDENTIFIER:
26764             case QUOTED_LITERAL:
26765             case SQLDATA_CLASS:
26766             case CUSTOMDATUM_CLASS:
26767             case ORADATA_CLASS:
26768             case JAVA_INTERFACE_CLASS:
26769               AttributeDeclaration();
26770               break;
26771             default:
26772               jj_la1[391] = jj_gen;
26773               jj_consume_token(-1);
26774               throw new ParseException();
26775             }
26776           }
26777         }
26778         jj_consume_token(7);
26779         break;
26780       default:
26781         jj_la1[392] = jj_gen;
26782         ;
26783       }
26784       label_92:
26785       while (true) {
26786         switch (jj_nt.kind) {
26787         case FINAL:
26788         case INSTANTIABLE:
26789         case NOT:
26790         case NULL:
26791           ;
26792           break;
26793         default:
26794           jj_la1[393] = jj_gen;
26795           break label_92;
26796         }
26797         switch (jj_nt.kind) {
26798         case NOT:
26799           jj_consume_token(NOT);
26800           break;
26801         default:
26802           jj_la1[394] = jj_gen;
26803           ;
26804         }
26805         switch (jj_nt.kind) {
26806         case FINAL:
26807           jj_consume_token(FINAL);
26808           break;
26809         case INSTANTIABLE:
26810           jj_consume_token(INSTANTIABLE);
26811           break;
26812         case NULL:
26813           jj_consume_token(NULL);
26814           break;
26815         default:
26816           jj_la1[395] = jj_gen;
26817           jj_consume_token(-1);
26818           throw new ParseException();
26819         }
26820       }
26821       switch (jj_nt.kind) {
26822       case CASCADE:
26823       case INVALIDATE:
26824         switch (jj_nt.kind) {
26825         case INVALIDATE:
26826           jj_consume_token(INVALIDATE);
26827           break;
26828         case CASCADE:
26829           jj_consume_token(CASCADE);
26830           label_93:
26831           while (true) {
26832             switch (jj_nt.kind) {
26833             case CONVERT:
26834             case INCLUDING:
26835             case NOT:
26836               ;
26837               break;
26838             default:
26839               jj_la1[396] = jj_gen;
26840               break label_93;
26841             }
26842             switch (jj_nt.kind) {
26843             case INCLUDING:
26844             case NOT:
26845               switch (jj_nt.kind) {
26846               case NOT:
26847                 jj_consume_token(NOT);
26848                 break;
26849               default:
26850                 jj_la1[397] = jj_gen;
26851                 ;
26852               }
26853               jj_consume_token(INCLUDING);
26854               jj_consume_token(TABLE);
26855               jj_consume_token(DATA);
26856               break;
26857             case CONVERT:
26858               jj_consume_token(CONVERT);
26859               jj_consume_token(TO);
26860               jj_consume_token(SUBSTITUTABLE);
26861               break;
26862             default:
26863               jj_la1[398] = jj_gen;
26864               jj_consume_token(-1);
26865               throw new ParseException();
26866             }
26867           }
26868           switch (jj_nt.kind) {
26869           case EXCEPTIONS:
26870           case FORCE:
26871             switch (jj_nt.kind) {
26872             case FORCE:
26873               jj_consume_token(FORCE);
26874               break;
26875             default:
26876               jj_la1[399] = jj_gen;
26877               ;
26878             }
26879             jj_consume_token(EXCEPTIONS);
26880             jj_consume_token(INTO);
26881             QualifiedName();
26882             break;
26883           default:
26884             jj_la1[400] = jj_gen;
26885             ;
26886           }
26887           break;
26888         default:
26889           jj_la1[401] = jj_gen;
26890           jj_consume_token(-1);
26891           throw new ParseException();
26892         }
26893         break;
26894       default:
26895         jj_la1[402] = jj_gen;
26896         ;
26897       }
26898         jjtree.closeNodeScope(jjtn000, true);
26899         jjtc000 = false;
26900         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26901     } catch (Throwable jjte000) {
26902           if (jjtc000) {
26903             jjtree.clearNodeScope(jjtn000);
26904             jjtc000 = false;
26905           } else {
26906             jjtree.popNode();
26907           }
26908           if (jjte000 instanceof RuntimeException) {
26909             {if (true) throw (RuntimeException)jjte000;}
26910           }
26911           if (jjte000 instanceof ParseException) {
26912             {if (true) throw (ParseException)jjte000;}
26913           }
26914           {if (true) throw (Error)jjte000;}
26915     } finally {
26916           if (jjtc000) {
26917             jjtree.closeNodeScope(jjtn000, true);
26918           }
26919     }
26920     throw new Error("Missing return statement in function");
26921   }
26922 
26923 /*
26924 ASTTypeBody TypeBody()  :
26925 { Token name=null; }
26926 {
26927 	[<CREATE> [<OR> <REPLACE>]]
26928 
26929 	<TYPE> <BODY> (LOOKAHEAD(2) ID()".")? name=ID()
26930 
26931 	(
26932 	  (
26933 	    WrappedObject() 
26934 	  )
26935 	  |
26936 	  (
26937 	    (<IS> | <AS>)
26938 
26939 		    DeclarativeSection() //SRT 20110524 Allow PLDOc in Type Bodies 
26940 
26941 	    [ <BEGIN> (Statement())* (ExceptionHandler())? ] <END> [ID()] ";" 
26942 	  )
26943 	)
26944 }
26945 */
26946 
26947 
26948 /**
26949   * Method 
26950 **/
26951   final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26952  /*@bgen(jjtree) AttributeDeclaration */
26953  ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26954  boolean jjtc000 = true;
26955  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26956     try {
26957       simpleNode = ID();
26958       Datatype();
26959         jjtree.closeNodeScope(jjtn000, true);
26960         jjtc000 = false;
26961         jjtn000.setImage(simpleNode.getImage()) ;   {if (true) return jjtn000 ;}
26962     } catch (Throwable jjte000) {
26963           if (jjtc000) {
26964             jjtree.clearNodeScope(jjtn000);
26965             jjtc000 = false;
26966           } else {
26967             jjtree.popNode();
26968           }
26969           if (jjte000 instanceof RuntimeException) {
26970             {if (true) throw (RuntimeException)jjte000;}
26971           }
26972           if (jjte000 instanceof ParseException) {
26973             {if (true) throw (ParseException)jjte000;}
26974           }
26975           {if (true) throw (Error)jjte000;}
26976     } finally {
26977           if (jjtc000) {
26978             jjtree.closeNodeScope(jjtn000, true);
26979           }
26980     }
26981     throw new Error("Missing return statement in function");
26982   }
26983 
26984   final public ASTAttribute Attribute() throws ParseException {
26985  /*@bgen(jjtree) Attribute */
26986  ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26987  boolean jjtc000 = true;
26988  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26989     try {
26990       simpleNode = ID();
26991         jjtree.closeNodeScope(jjtn000, true);
26992         jjtc000 = false;
26993         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26994     } catch (Throwable jjte000) {
26995         if (jjtc000) {
26996           jjtree.clearNodeScope(jjtn000);
26997           jjtc000 = false;
26998         } else {
26999           jjtree.popNode();
27000         }
27001         if (jjte000 instanceof RuntimeException) {
27002           {if (true) throw (RuntimeException)jjte000;}
27003         }
27004         if (jjte000 instanceof ParseException) {
27005           {if (true) throw (ParseException)jjte000;}
27006         }
27007         {if (true) throw (Error)jjte000;}
27008     } finally {
27009         if (jjtc000) {
27010           jjtree.closeNodeScope(jjtn000, true);
27011         }
27012     }
27013     throw new Error("Missing return statement in function");
27014   }
27015 
27016 /*
27017  This was quick cut from PRAGMA
27018 */
27019   final public ASTPragmaClause PragmaClause() throws ParseException {
27020  /*@bgen(jjtree) PragmaClause */
27021   ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
27022   boolean jjtc000 = true;
27023   jjtree.openNodeScope(jjtn000);
27024     try {
27025       jj_consume_token(PRAGMA);
27026       switch (jj_nt.kind) {
27027       case SERIALLY_REUSABLE:
27028         jj_consume_token(SERIALLY_REUSABLE);
27029         break;
27030       case AUTONOMOUS_TRANSACTION:
27031         jj_consume_token(AUTONOMOUS_TRANSACTION);
27032         break;
27033       case RESTRICT_REFERENCES:
27034         jj_consume_token(RESTRICT_REFERENCES);
27035         jj_consume_token(5);
27036         ID();
27037         label_94:
27038         while (true) {
27039           jj_consume_token(6);
27040           switch (jj_nt.kind) {
27041           case REPLACE:
27042           case DEFINER:
27043           case CURRENT_USER:
27044           case SERIALLY_REUSABLE:
27045           case RESTRICT_REFERENCES:
27046           case EXCEPTION_INIT:
27047           case AUTONOMOUS_TRANSACTION:
27048           case LANGUAGE:
27049           case INLINE:
27050           case ADD:
27051           case AGGREGATE:
27052           case ALL:
27053           case ALTER:
27054           case AND:
27055           case ANY:
27056           case ARRAY:
27057           case AS:
27058           case ASC:
27059           case AT:
27060           case ATTRIBUTE:
27061           case AUTHID:
27062           case AVG:
27063           case BETWEEN:
27064           case BINARY_INTEGER:
27065           case BODY:
27066           case BOOLEAN:
27067           case BULK:
27068           case BY:
27069           case BYTE:
27070           case CASCADE:
27071           case CASE:
27072           case CHAR:
27073           case CHAR_BASE:
27074           case CHECK:
27075           case CLOSE:
27076           case CLUSTER:
27077           case COALESCE:
27078           case COLLECT:
27079           case COLUMN:
27080           case COMMENT:
27081           case COMMIT:
27082           case COMPRESS:
27083           case CONNECT:
27084           case CONSTANT:
27085           case CONSTRUCTOR:
27086           case CONTINUE:
27087           case CONVERT:
27088           case CREATE:
27089           case CURRENT:
27090           case CURRVAL:
27091           case CURSOR:
27092           case DATA:
27093           case DATE:
27094           case DAY:
27095           case DECLARE:
27096           case DECIMAL:
27097           case _DEFAULT:
27098           case DELETE:
27099           case DESC:
27100           case DISABLE:
27101           case DISTINCT:
27102           case DO:
27103           case DROP:
27104           case EDITIONABLE:
27105           case ELEMENT:
27106           case ELSE:
27107           case ELSIF:
27108           case ENABLE:
27109           case ESCAPE:
27110           case EXCEPT:
27111           case EXCEPTION:
27112           case EXCEPTIONS:
27113           case EXCLUSIVE:
27114           case EXECUTE:
27115           case EXISTS:
27116           case EXIT:
27117           case EXTERNAL:
27118           case EXTENDS:
27119           case EXTRACT:
27120           case FALSE:
27121           case FETCH:
27122           case FINAL:
27123           case FLOAT:
27124           case FOR:
27125           case FORALL:
27126           case FORCE:
27127           case FROM:
27128           case FUNCTION:
27129           case GLOBAL:
27130           case GOTO:
27131           case GROUP:
27132           case HASH:
27133           case HAVING:
27134           case HEAP:
27135           case HOUR:
27136           case IF:
27137           case IMMEDIATE:
27138           case IN:
27139           case INDEX:
27140           case INDICES:
27141           case INDEXTYPE:
27142           case INDICATOR:
27143           case INSERT:
27144           case INSTANTIABLE:
27145           case INTEGER:
27146           case INTERFACE:
27147           case INTERSECT:
27148           case INTERVAL:
27149           case INTO:
27150           case INVALIDATE:
27151           case IS:
27152           case ISOLATION:
27153           case JAVA:
27154           case LEVEL:
27155           case LIKE:
27156           case LIMIT:
27157           case LIMITED:
27158           case LOCK:
27159           case LONG:
27160           case LOOP:
27161           case MAP:
27162           case MAX:
27163           case MEMBER:
27164           case MERGE:
27165           case MIN:
27166           case MINUS:
27167           case MINUTE:
27168           case MLSLABEL:
27169           case MODIFY:
27170           case MOD:
27171           case MODE:
27172           case MONTH:
27173           case NATURAL:
27174           case NATURALN:
27175           case NEW:
27176           case NEXTVAL:
27177           case NO:
27178           case NOCOPY:
27179           case NONEDITIONABLE:
27180           case NOT:
27181           case NOWAIT:
27182           case NULL:
27183           case NULLIF:
27184           case NUMBER:
27185           case BFILE_BASE:
27186           case BLOB_BASE:
27187           case CLOB_BASE:
27188           case DATE_BASE:
27189           case NUMBER_BASE:
27190           case OBJECT:
27191           case OCIROWID:
27192           case OF:
27193           case OID:
27194           case ON:
27195           case OPAQUE:
27196           case OPEN:
27197           case OPERATOR:
27198           case OPTION:
27199           case OR:
27200           case ORDER:
27201           case ORGANIZATION:
27202           case OTHERS:
27203           case OUT:
27204           case OVERRIDING:
27205           case PACKAGE:
27206           case PARTITION:
27207           case PCTFREE:
27208           case PLS_INTEGER:
27209           case POSITIVE:
27210           case POSITIVEN:
27211           case PRESERVE:
27212           case PRIOR:
27213           case PROMPT:
27214           case PRIVATE:
27215           case PROCEDURE:
27216           case PUBLIC:
27217           case RAISE:
27218           case RANGE:
27219           case RAW:
27220           case REAL:
27221           case RECORD:
27222           case REF:
27223           case RELEASE:
27224           case RELIES_ON:
27225           case RENAME:
27226           case RESULT:
27227           case RETURN:
27228           case RETURNING:
27229           case REVERSE:
27230           case ROLLBACK:
27231           case ROW:
27232           case ROWS:
27233           case ROWID:
27234           case ROWNUM:
27235           case ROWTYPE:
27236           case SAVE:
27237           case SAVEPOINT:
27238           case SECOND:
27239           case SELECT:
27240           case SELF:
27241           case SEPARATE:
27242           case SET:
27243           case SHARE:
27244           case SMALLINT:
27245           case SPACE:
27246           case SQL:
27247           case SQLCODE:
27248           case SQLERRM:
27249           case START:
27250           case STATIC:
27251           case STDDEV:
27252           case SUBTYPE:
27253           case SUBSTITUTABLE:
27254           case SUCCESSFUL:
27255           case SUM:
27256           case SYNONYM:
27257           case SYSDATE:
27258           case SYS_REFCURSOR:
27259           case TABLE:
27260           case TEMPORARY:
27261           case THEN:
27262           case TIME:
27263           case TIMESTAMP:
27264           case TIMEZONE_REGION:
27265           case TIMEZONE_ABBR:
27266           case TIMEZONE_MINUTE:
27267           case TIMEZONE_HOUR:
27268           case TO:
27269           case TRANSACTION:
27270           case TRIGGER:
27271           case TRUE:
27272           case TYPE:
27273           case UI:
27274           case UNDER:
27275           case USING:
27276           case WHILE:
27277           case YES:
27278           case SHOW:
27279           case A:
27280           case UPDATE:
27281           case VARCHAR:
27282           case VARCHAR2:
27283           case DOUBLE:
27284           case DEC:
27285           case PRECISION:
27286           case INT:
27287           case NUMERIC:
27288           case SIGNTYPE:
27289           case NCHAR:
27290           case NVARCHAR2:
27291           case STRING:
27292           case UROWID:
27293           case VARRAY:
27294           case VARYING:
27295           case BFILE:
27296           case BLOB:
27297           case CLOB:
27298           case NCLOB:
27299           case YEAR:
27300           case LOCAL:
27301           case WITH:
27302           case ZONE:
27303           case CHARACTER:
27304           case AFTER:
27305           case BEFORE:
27306           case OLD:
27307           case PARENT:
27308           case ANALYZE:
27309           case ASSOCIATE:
27310           case AUDIT:
27311           case COMPOUND:
27312           case DATABASE:
27313           case CALL:
27314           case DDL:
27315           case DISASSOCIATE:
27316           case EACH:
27317           case FOLLOWS:
27318           case LOGOFF:
27319           case LOGON:
27320           case NESTED:
27321           case NOAUDIT:
27322           case SCHEMA:
27323           case SERVERERROR:
27324           case SHUTDOWN:
27325           case STARTUP:
27326           case STATEMENT:
27327           case STATISTICS:
27328           case SUSPEND:
27329           case TRUNCATE:
27330           case WRAPPED:
27331           case LIBRARY:
27332           case NAME:
27333           case STRUCT:
27334           case CONTEXT:
27335           case PARAMETERS:
27336           case LENGTH:
27337           case TDO:
27338           case MAXLEN:
27339           case CHARSETID:
27340           case CHARSETFORM:
27341           case ACCEPT:
27342           case ACCESSIBLE:
27343           case COPY:
27344           case DEFINE:
27345           case DISCONNECT:
27346           case HOST:
27347           case PRINT:
27348           case QUIT:
27349           case REMARK:
27350           case UNDEFINE:
27351           case VARIABLE:
27352           case WHENEVER:
27353           case ATTACH:
27354           case CAST:
27355           case TREAT:
27356           case TRIM:
27357           case LEFT:
27358           case RIGHT:
27359           case BOTH:
27360           case EMPTY:
27361           case MULTISET:
27362           case SUBMULTISET:
27363           case LEADING:
27364           case TRAILING:
27365           case CHAR_CS:
27366           case NCHAR_CS:
27367           case DBTIMEZONE:
27368           case SESSIONTIMEZONE:
27369           case AUTHENTICATED:
27370           case LINK:
27371           case SHARED:
27372           case DIRECTORY:
27373           case USER:
27374           case IDENTIFIER:
27375           case QUOTED_LITERAL:
27376           case SQLDATA_CLASS:
27377           case CUSTOMDATUM_CLASS:
27378           case ORADATA_CLASS:
27379           case JAVA_INTERFACE_CLASS:
27380             ID();
27381             break;
27382           case STRING_LITERAL:
27383             StringLiteral();
27384             break;
27385           default:
27386             jj_la1[403] = jj_gen;
27387             jj_consume_token(-1);
27388             throw new ParseException();
27389           }
27390           switch (jj_nt.kind) {
27391           case 6:
27392             ;
27393             break;
27394           default:
27395             jj_la1[404] = jj_gen;
27396             break label_94;
27397           }
27398         }
27399         jj_consume_token(7);
27400         break;
27401       case EXCEPTION_INIT:
27402         jj_consume_token(EXCEPTION_INIT);
27403         jj_consume_token(5);
27404         jj_consume_token(IDENTIFIER);
27405         jj_consume_token(6);
27406         switch (jj_nt.kind) {
27407         case 16:
27408         case 17:
27409           switch (jj_nt.kind) {
27410           case 16:
27411             jj_consume_token(16);
27412             break;
27413           case 17:
27414             jj_consume_token(17);
27415             break;
27416           default:
27417             jj_la1[405] = jj_gen;
27418             jj_consume_token(-1);
27419             throw new ParseException();
27420           }
27421           break;
27422         default:
27423           jj_la1[406] = jj_gen;
27424           ;
27425         }
27426         NumericLiteral();
27427         jj_consume_token(7);
27428         break;
27429       case INTERFACE:
27430         jj_consume_token(INTERFACE);
27431         jj_consume_token(5);
27432         jj_consume_token(IDENTIFIER);
27433         jj_consume_token(6);
27434         jj_consume_token(IDENTIFIER);
27435         jj_consume_token(6);
27436         NumericLiteral();
27437         jj_consume_token(7);
27438         break;
27439       default:
27440         jj_la1[407] = jj_gen;
27441         jj_consume_token(-1);
27442         throw new ParseException();
27443       }
27444         jjtree.closeNodeScope(jjtn000, true);
27445         jjtc000 = false;
27446         {if (true) return jjtn000 ;}
27447     } catch (Throwable jjte000) {
27448           if (jjtc000) {
27449             jjtree.clearNodeScope(jjtn000);
27450             jjtc000 = false;
27451           } else {
27452             jjtree.popNode();
27453           }
27454           if (jjte000 instanceof RuntimeException) {
27455             {if (true) throw (RuntimeException)jjte000;}
27456           }
27457           if (jjte000 instanceof ParseException) {
27458             {if (true) throw (ParseException)jjte000;}
27459           }
27460           {if (true) throw (Error)jjte000;}
27461     } finally {
27462           if (jjtc000) {
27463             jjtree.closeNodeScope(jjtn000, true);
27464           }
27465     }
27466     throw new Error("Missing return statement in function");
27467   }
27468 
27469 /** 
27470  * Trigger
27471  * Triggers are always outside of a package.
27472  *
27473  *  2006-05-17 - Matthias Hendler - added 
27474  */
27475 
27476 /*
27477   11g Trigger Syntax 
27478 
27479  create_trigger : 
27480  CREATE [OR REPLACE] TRIGGER [schema.]trigger 
27481 ( simple_dml_trigger | compound_dml_trigger | non_dml_trigger )
27482 [ FOLLOWS ( [schema.]trigger) ( , [schema.]trigger)*  ]
27483 [ ENABLE  | DISABLE ]
27484 ( WHEN ( trigger_condition ) 
27485 trigger_body
27486 
27487 
27488 simple_dml_trigger :
27489 (BEFORE |AFTER | INSTEAD OF)
27490 dml_event_clause 
27491 [ referencing_clause ]
27492 [ FOR EACH ROW ]
27493 
27494 
27495 
27496 compound_dml_trigger :
27497 FOR dml_event_clause 
27498 [ referencing_clause ]
27499 
27500 
27501 non_dml_trigger :
27502 (BEFORE> |<AFTER> ) 
27503 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
27504 ON
27505 (DATABASE | [schema.]SCHEMA
27506 
27507 
27508 
27509 trigger_body :
27510 (plsql_block | compound_trigger_block | CALL routine_clause)
27511 
27512 
27513 
27514 dml_event_clause:
27515 ( DELETE | INSERT | UPDATE [ OF column (, column ) ] )
27516 ON ( (schema.table | NESTED TABLE nested_table_column OF [schema.]view )
27517 
27518 referencing_clause:
27519 REFERENCING 
27520 (OLD AS old_alias | NEW AS new_alias | PARENT AS parent_alias )*  
27521 
27522 
27523 compound_trigger_block :
27524 COMPOUND TRIGGER 
27525 declare_section 
27526 (timing_point_section)+  
27527 END [trigger_name] ;
27528 
27529 timing_point_section:
27530 (
27531 BEFORE STATEMENT IS tps_body END BEFORE STATEMENT 
27532 |BEFORE EACH ROW IS tps_body END BEFORE EACH ROW 
27533 |AFTER STATEMENT IS tps_body END AFTER STATEMENT 
27534 |AFTER EACH ROW IS tps_body END AFTER EACH ROW 
27535 )
27536 
27537 
27538 tps_body:
27539 (statement)+
27540 (EXCEPTION exception_handler )*
27541 
27542 */
27543   final public ASTTriggerUnit TriggerUnit() throws ParseException {
27544  /*@bgen(jjtree) TriggerUnit */
27545  ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27546  boolean jjtc000 = true;
27547  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27548     try {
27549       switch (jj_nt.kind) {
27550       case CREATE:
27551         jj_consume_token(CREATE);
27552         switch (jj_nt.kind) {
27553         case OR:
27554           jj_consume_token(OR);
27555           jj_consume_token(REPLACE);
27556           break;
27557         default:
27558           jj_la1[408] = jj_gen;
27559           ;
27560         }
27561         switch (jj_nt.kind) {
27562         case EDITIONABLE:
27563         case NONEDITIONABLE:
27564           switch (jj_nt.kind) {
27565           case EDITIONABLE:
27566             jj_consume_token(EDITIONABLE);
27567             break;
27568           case NONEDITIONABLE:
27569             jj_consume_token(NONEDITIONABLE);
27570             break;
27571           default:
27572             jj_la1[409] = jj_gen;
27573             jj_consume_token(-1);
27574             throw new ParseException();
27575           }
27576           break;
27577         default:
27578           jj_la1[410] = jj_gen;
27579           ;
27580         }
27581         break;
27582       default:
27583         jj_la1[411] = jj_gen;
27584         ;
27585       }
27586       jj_consume_token(TRIGGER);
27587       simpleNode = ObjectNameDeclaration();
27588       switch (jj_nt.kind) {
27589       case BEFORE:
27590         jj_consume_token(BEFORE);
27591         break;
27592       case AFTER:
27593         jj_consume_token(AFTER);
27594         break;
27595       case INSTEADOF:
27596         jj_consume_token(INSTEADOF);
27597         break;
27598       case FOR:
27599         jj_consume_token(FOR);
27600         break;
27601       default:
27602         jj_la1[412] = jj_gen;
27603         jj_consume_token(-1);
27604         throw new ParseException();
27605       }
27606       switch (jj_nt.kind) {
27607       case DELETE:
27608       case INSERT:
27609       case UPDATE:
27610         switch (jj_nt.kind) {
27611         case DELETE:
27612           jj_consume_token(DELETE);
27613           break;
27614         case INSERT:
27615           jj_consume_token(INSERT);
27616           break;
27617         case UPDATE:
27618           jj_consume_token(UPDATE);
27619           break;
27620         default:
27621           jj_la1[413] = jj_gen;
27622           jj_consume_token(-1);
27623           throw new ParseException();
27624         }
27625         if (jj_2_74(6)) {
27626           jj_consume_token(OF);
27627           ID();
27628           label_95:
27629           while (true) {
27630             switch (jj_nt.kind) {
27631             case 6:
27632               ;
27633               break;
27634             default:
27635               jj_la1[414] = jj_gen;
27636               break label_95;
27637             }
27638             jj_consume_token(6);
27639             ID();
27640           }
27641         } else {
27642           ;
27643         }
27644         break;
27645       case ALTER:
27646       case COMMENT:
27647       case CREATE:
27648       case DROP:
27649       case GRANT:
27650       case RENAME:
27651       case REVOKE:
27652       case ANALYZE:
27653       case ASSOCIATE:
27654       case AUDIT:
27655       case DDL:
27656       case DISASSOCIATE:
27657       case LOGOFF:
27658       case LOGON:
27659       case NOAUDIT:
27660       case SERVERERROR:
27661       case SHUTDOWN:
27662       case STARTUP:
27663       case SUSPEND:
27664       case TRUNCATE:
27665         NonDMLEvent();
27666         break;
27667       default:
27668         jj_la1[415] = jj_gen;
27669         jj_consume_token(-1);
27670         throw new ParseException();
27671       }
27672       label_96:
27673       while (true) {
27674         switch (jj_nt.kind) {
27675         case OR:
27676           ;
27677           break;
27678         default:
27679           jj_la1[416] = jj_gen;
27680           break label_96;
27681         }
27682         jj_consume_token(OR);
27683         switch (jj_nt.kind) {
27684         case DELETE:
27685         case INSERT:
27686         case UPDATE:
27687           switch (jj_nt.kind) {
27688           case DELETE:
27689             jj_consume_token(DELETE);
27690             break;
27691           case INSERT:
27692             jj_consume_token(INSERT);
27693             break;
27694           case UPDATE:
27695             jj_consume_token(UPDATE);
27696             break;
27697           default:
27698             jj_la1[417] = jj_gen;
27699             jj_consume_token(-1);
27700             throw new ParseException();
27701           }
27702           if (jj_2_75(6)) {
27703             jj_consume_token(OF);
27704             ID();
27705             label_97:
27706             while (true) {
27707               switch (jj_nt.kind) {
27708               case 6:
27709                 ;
27710                 break;
27711               default:
27712                 jj_la1[418] = jj_gen;
27713                 break label_97;
27714               }
27715               jj_consume_token(6);
27716               ID();
27717             }
27718           } else {
27719             ;
27720           }
27721           break;
27722         case ALTER:
27723         case COMMENT:
27724         case CREATE:
27725         case DROP:
27726         case GRANT:
27727         case RENAME:
27728         case REVOKE:
27729         case ANALYZE:
27730         case ASSOCIATE:
27731         case AUDIT:
27732         case DDL:
27733         case DISASSOCIATE:
27734         case LOGOFF:
27735         case LOGON:
27736         case NOAUDIT:
27737         case SERVERERROR:
27738         case SHUTDOWN:
27739         case STARTUP:
27740         case SUSPEND:
27741         case TRUNCATE:
27742           NonDMLEvent();
27743           break;
27744         default:
27745           jj_la1[419] = jj_gen;
27746           jj_consume_token(-1);
27747           throw new ParseException();
27748         }
27749       }
27750       jj_consume_token(ON);
27751       switch (jj_nt.kind) {
27752       case DATABASE:
27753         jj_consume_token(DATABASE);
27754         break;
27755       default:
27756         jj_la1[420] = jj_gen;
27757         if (jj_2_78(2)) {
27758           jj_consume_token(NESTED);
27759           jj_consume_token(TABLE);
27760           ID();
27761           jj_consume_token(OF);
27762           if (jj_2_76(2)) {
27763             ID();
27764             jj_consume_token(3);
27765           } else {
27766             ;
27767           }
27768           ID();
27769         } else {
27770           switch (jj_nt.kind) {
27771           case REPLACE:
27772           case DEFINER:
27773           case CURRENT_USER:
27774           case SERIALLY_REUSABLE:
27775           case RESTRICT_REFERENCES:
27776           case EXCEPTION_INIT:
27777           case AUTONOMOUS_TRANSACTION:
27778           case LANGUAGE:
27779           case INLINE:
27780           case ADD:
27781           case AGGREGATE:
27782           case ALL:
27783           case ALTER:
27784           case AND:
27785           case ANY:
27786           case ARRAY:
27787           case AS:
27788           case ASC:
27789           case AT:
27790           case ATTRIBUTE:
27791           case AUTHID:
27792           case AVG:
27793           case BETWEEN:
27794           case BINARY_INTEGER:
27795           case BODY:
27796           case BOOLEAN:
27797           case BULK:
27798           case BY:
27799           case BYTE:
27800           case CASCADE:
27801           case CASE:
27802           case CHAR:
27803           case CHAR_BASE:
27804           case CHECK:
27805           case CLOSE:
27806           case CLUSTER:
27807           case COALESCE:
27808           case COLLECT:
27809           case COLUMN:
27810           case COMMENT:
27811           case COMMIT:
27812           case COMPRESS:
27813           case CONNECT:
27814           case CONSTANT:
27815           case CONSTRUCTOR:
27816           case CONTINUE:
27817           case CONVERT:
27818           case CREATE:
27819           case CURRENT:
27820           case CURRVAL:
27821           case CURSOR:
27822           case DATA:
27823           case DATE:
27824           case DAY:
27825           case DECLARE:
27826           case DECIMAL:
27827           case _DEFAULT:
27828           case DELETE:
27829           case DESC:
27830           case DISABLE:
27831           case DISTINCT:
27832           case DO:
27833           case DROP:
27834           case EDITIONABLE:
27835           case ELEMENT:
27836           case ELSE:
27837           case ELSIF:
27838           case ENABLE:
27839           case ESCAPE:
27840           case EXCEPT:
27841           case EXCEPTION:
27842           case EXCEPTIONS:
27843           case EXCLUSIVE:
27844           case EXECUTE:
27845           case EXISTS:
27846           case EXIT:
27847           case EXTERNAL:
27848           case EXTENDS:
27849           case EXTRACT:
27850           case FALSE:
27851           case FETCH:
27852           case FINAL:
27853           case FLOAT:
27854           case FOR:
27855           case FORALL:
27856           case FORCE:
27857           case FROM:
27858           case FUNCTION:
27859           case GLOBAL:
27860           case GOTO:
27861           case GROUP:
27862           case HASH:
27863           case HAVING:
27864           case HEAP:
27865           case HOUR:
27866           case IF:
27867           case IMMEDIATE:
27868           case IN:
27869           case INDEX:
27870           case INDICES:
27871           case INDEXTYPE:
27872           case INDICATOR:
27873           case INSERT:
27874           case INSTANTIABLE:
27875           case INTEGER:
27876           case INTERFACE:
27877           case INTERSECT:
27878           case INTERVAL:
27879           case INTO:
27880           case INVALIDATE:
27881           case IS:
27882           case ISOLATION:
27883           case JAVA:
27884           case LEVEL:
27885           case LIKE:
27886           case LIMIT:
27887           case LIMITED:
27888           case LOCK:
27889           case LONG:
27890           case LOOP:
27891           case MAP:
27892           case MAX:
27893           case MEMBER:
27894           case MERGE:
27895           case MIN:
27896           case MINUS:
27897           case MINUTE:
27898           case MLSLABEL:
27899           case MODIFY:
27900           case MOD:
27901           case MODE:
27902           case MONTH:
27903           case NATURAL:
27904           case NATURALN:
27905           case NEW:
27906           case NEXTVAL:
27907           case NO:
27908           case NOCOPY:
27909           case NONEDITIONABLE:
27910           case NOT:
27911           case NOWAIT:
27912           case NULL:
27913           case NULLIF:
27914           case NUMBER:
27915           case BFILE_BASE:
27916           case BLOB_BASE:
27917           case CLOB_BASE:
27918           case DATE_BASE:
27919           case NUMBER_BASE:
27920           case OBJECT:
27921           case OCIROWID:
27922           case OF:
27923           case OID:
27924           case ON:
27925           case OPAQUE:
27926           case OPEN:
27927           case OPERATOR:
27928           case OPTION:
27929           case OR:
27930           case ORDER:
27931           case ORGANIZATION:
27932           case OTHERS:
27933           case OUT:
27934           case OVERRIDING:
27935           case PACKAGE:
27936           case PARTITION:
27937           case PCTFREE:
27938           case PLS_INTEGER:
27939           case POSITIVE:
27940           case POSITIVEN:
27941           case PRESERVE:
27942           case PRIOR:
27943           case PROMPT:
27944           case PRIVATE:
27945           case PROCEDURE:
27946           case PUBLIC:
27947           case RAISE:
27948           case RANGE:
27949           case RAW:
27950           case REAL:
27951           case RECORD:
27952           case REF:
27953           case RELEASE:
27954           case RELIES_ON:
27955           case RENAME:
27956           case RESULT:
27957           case RETURN:
27958           case RETURNING:
27959           case REVERSE:
27960           case ROLLBACK:
27961           case ROW:
27962           case ROWS:
27963           case ROWID:
27964           case ROWNUM:
27965           case ROWTYPE:
27966           case SAVE:
27967           case SAVEPOINT:
27968           case SECOND:
27969           case SELECT:
27970           case SELF:
27971           case SEPARATE:
27972           case SET:
27973           case SHARE:
27974           case SMALLINT:
27975           case SPACE:
27976           case SQL:
27977           case SQLCODE:
27978           case SQLERRM:
27979           case START:
27980           case STATIC:
27981           case STDDEV:
27982           case SUBTYPE:
27983           case SUBSTITUTABLE:
27984           case SUCCESSFUL:
27985           case SUM:
27986           case SYNONYM:
27987           case SYSDATE:
27988           case SYS_REFCURSOR:
27989           case TABLE:
27990           case TEMPORARY:
27991           case THEN:
27992           case TIME:
27993           case TIMESTAMP:
27994           case TIMEZONE_REGION:
27995           case TIMEZONE_ABBR:
27996           case TIMEZONE_MINUTE:
27997           case TIMEZONE_HOUR:
27998           case TO:
27999           case TRANSACTION:
28000           case TRIGGER:
28001           case TRUE:
28002           case TYPE:
28003           case UI:
28004           case UNDER:
28005           case USING:
28006           case WHILE:
28007           case YES:
28008           case SHOW:
28009           case A:
28010           case UPDATE:
28011           case VARCHAR:
28012           case VARCHAR2:
28013           case DOUBLE:
28014           case DEC:
28015           case PRECISION:
28016           case INT:
28017           case NUMERIC:
28018           case SIGNTYPE:
28019           case NCHAR:
28020           case NVARCHAR2:
28021           case STRING:
28022           case UROWID:
28023           case VARRAY:
28024           case VARYING:
28025           case BFILE:
28026           case BLOB:
28027           case CLOB:
28028           case NCLOB:
28029           case YEAR:
28030           case LOCAL:
28031           case WITH:
28032           case ZONE:
28033           case CHARACTER:
28034           case AFTER:
28035           case BEFORE:
28036           case OLD:
28037           case PARENT:
28038           case ANALYZE:
28039           case ASSOCIATE:
28040           case AUDIT:
28041           case COMPOUND:
28042           case DATABASE:
28043           case CALL:
28044           case DDL:
28045           case DISASSOCIATE:
28046           case EACH:
28047           case FOLLOWS:
28048           case LOGOFF:
28049           case LOGON:
28050           case NESTED:
28051           case NOAUDIT:
28052           case SCHEMA:
28053           case SERVERERROR:
28054           case SHUTDOWN:
28055           case STARTUP:
28056           case STATEMENT:
28057           case STATISTICS:
28058           case SUSPEND:
28059           case TRUNCATE:
28060           case WRAPPED:
28061           case LIBRARY:
28062           case NAME:
28063           case STRUCT:
28064           case CONTEXT:
28065           case PARAMETERS:
28066           case LENGTH:
28067           case TDO:
28068           case MAXLEN:
28069           case CHARSETID:
28070           case CHARSETFORM:
28071           case ACCEPT:
28072           case ACCESSIBLE:
28073           case COPY:
28074           case DEFINE:
28075           case DISCONNECT:
28076           case HOST:
28077           case PRINT:
28078           case QUIT:
28079           case REMARK:
28080           case UNDEFINE:
28081           case VARIABLE:
28082           case WHENEVER:
28083           case ATTACH:
28084           case CAST:
28085           case TREAT:
28086           case TRIM:
28087           case LEFT:
28088           case RIGHT:
28089           case BOTH:
28090           case EMPTY:
28091           case MULTISET:
28092           case SUBMULTISET:
28093           case LEADING:
28094           case TRAILING:
28095           case CHAR_CS:
28096           case NCHAR_CS:
28097           case DBTIMEZONE:
28098           case SESSIONTIMEZONE:
28099           case AUTHENTICATED:
28100           case LINK:
28101           case SHARED:
28102           case DIRECTORY:
28103           case USER:
28104           case IDENTIFIER:
28105           case QUOTED_LITERAL:
28106           case SQLDATA_CLASS:
28107           case CUSTOMDATUM_CLASS:
28108           case ORADATA_CLASS:
28109           case JAVA_INTERFACE_CLASS:
28110             if (jj_2_77(2)) {
28111               ID();
28112               jj_consume_token(3);
28113             } else {
28114               ;
28115             }
28116             ID();
28117             break;
28118           default:
28119             jj_la1[421] = jj_gen;
28120             jj_consume_token(-1);
28121             throw new ParseException();
28122           }
28123         }
28124       }
28125       switch (jj_nt.kind) {
28126       case REFERENCING:
28127         jj_consume_token(REFERENCING);
28128         label_98:
28129         while (true) {
28130           switch (jj_nt.kind) {
28131           case NEW:
28132           case OLD:
28133           case PARENT:
28134             ;
28135             break;
28136           default:
28137             jj_la1[422] = jj_gen;
28138             break label_98;
28139           }
28140           switch (jj_nt.kind) {
28141           case OLD:
28142             jj_consume_token(OLD);
28143             break;
28144           case NEW:
28145             jj_consume_token(NEW);
28146             break;
28147           case PARENT:
28148             jj_consume_token(PARENT);
28149             break;
28150           default:
28151             jj_la1[423] = jj_gen;
28152             jj_consume_token(-1);
28153             throw new ParseException();
28154           }
28155           jj_consume_token(AS);
28156           ID();
28157         }
28158         break;
28159       default:
28160         jj_la1[424] = jj_gen;
28161         ;
28162       }
28163       switch (jj_nt.kind) {
28164       case FOREACHROW:
28165         jj_consume_token(FOREACHROW);
28166         break;
28167       default:
28168         jj_la1[425] = jj_gen;
28169         ;
28170       }
28171       switch (jj_nt.kind) {
28172       case REVERSE:
28173       case FORWARD:
28174       case CROSSEDITION:
28175         switch (jj_nt.kind) {
28176         case REVERSE:
28177         case FORWARD:
28178           switch (jj_nt.kind) {
28179           case FORWARD:
28180             jj_consume_token(FORWARD);
28181             break;
28182           case REVERSE:
28183             jj_consume_token(REVERSE);
28184             break;
28185           default:
28186             jj_la1[426] = jj_gen;
28187             jj_consume_token(-1);
28188             throw new ParseException();
28189           }
28190           break;
28191         default:
28192           jj_la1[427] = jj_gen;
28193           ;
28194         }
28195         jj_consume_token(CROSSEDITION);
28196         break;
28197       default:
28198         jj_la1[428] = jj_gen;
28199         ;
28200       }
28201       switch (jj_nt.kind) {
28202       case FOLLOWS:
28203       case PRECEDES:
28204         switch (jj_nt.kind) {
28205         case FOLLOWS:
28206           jj_consume_token(FOLLOWS);
28207           break;
28208         case PRECEDES:
28209           jj_consume_token(PRECEDES);
28210           break;
28211         default:
28212           jj_la1[429] = jj_gen;
28213           jj_consume_token(-1);
28214           throw new ParseException();
28215         }
28216         if (jj_2_79(2)) {
28217           ID();
28218           jj_consume_token(3);
28219         } else {
28220           ;
28221         }
28222         ID();
28223         label_99:
28224         while (true) {
28225           switch (jj_nt.kind) {
28226           case 6:
28227             ;
28228             break;
28229           default:
28230             jj_la1[430] = jj_gen;
28231             break label_99;
28232           }
28233           jj_consume_token(6);
28234           if (jj_2_80(2)) {
28235             ID();
28236             jj_consume_token(3);
28237           } else {
28238             ;
28239           }
28240           ID();
28241         }
28242         break;
28243       default:
28244         jj_la1[431] = jj_gen;
28245         ;
28246       }
28247       switch (jj_nt.kind) {
28248       case DISABLE:
28249       case ENABLE:
28250         switch (jj_nt.kind) {
28251         case ENABLE:
28252           jj_consume_token(ENABLE);
28253           break;
28254         case DISABLE:
28255           jj_consume_token(DISABLE);
28256           break;
28257         default:
28258           jj_la1[432] = jj_gen;
28259           jj_consume_token(-1);
28260           throw new ParseException();
28261         }
28262         break;
28263       default:
28264         jj_la1[433] = jj_gen;
28265         ;
28266       }
28267       switch (jj_nt.kind) {
28268       case WHEN:
28269         jj_consume_token(WHEN);
28270         jj_consume_token(5);
28271         ConditionalOrExpression();
28272         jj_consume_token(7);
28273         break;
28274       default:
28275         jj_la1[434] = jj_gen;
28276         ;
28277       }
28278       switch (jj_nt.kind) {
28279       case CALL:
28280         jj_consume_token(CALL);
28281         PrimaryExpression();
28282         jj_consume_token(4);
28283         break;
28284       case COMPOUND:
28285         CompoundTriggerBlock();
28286         break;
28287       case BEGIN:
28288       case DECLARE:
28289         Block();
28290         jj_consume_token(4);
28291         break;
28292       default:
28293         jj_la1[435] = jj_gen;
28294         jj_consume_token(-1);
28295         throw new ParseException();
28296       }
28297         jjtree.closeNodeScope(jjtn000, true);
28298         jjtc000 = false;
28299         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
28300     } catch (Throwable jjte000) {
28301           if (jjtc000) {
28302             jjtree.clearNodeScope(jjtn000);
28303             jjtc000 = false;
28304           } else {
28305             jjtree.popNode();
28306           }
28307           if (jjte000 instanceof RuntimeException) {
28308             {if (true) throw (RuntimeException)jjte000;}
28309           }
28310           if (jjte000 instanceof ParseException) {
28311             {if (true) throw (ParseException)jjte000;}
28312           }
28313           {if (true) throw (Error)jjte000;}
28314     } finally {
28315           if (jjtc000) {
28316             jjtree.closeNodeScope(jjtn000, true);
28317           }
28318     }
28319     throw new Error("Missing return statement in function");
28320   }
28321 
28322   final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28323  /*@bgen(jjtree) TriggerTimingPointSection */
28324  ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28325  boolean jjtc000 = true;
28326  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28327     try {
28328       switch (jj_nt.kind) {
28329       case BEFORE:
28330         jj_consume_token(BEFORE);
28331         break;
28332       case AFTER:
28333         jj_consume_token(AFTER);
28334         break;
28335       case INSTEADOF:
28336         jj_consume_token(INSTEADOF);
28337         break;
28338       default:
28339         jj_la1[436] = jj_gen;
28340         jj_consume_token(-1);
28341         throw new ParseException();
28342       }
28343                                         sb.append(token.image) ;
28344       switch (jj_nt.kind) {
28345       case STATEMENT:
28346         jj_consume_token(STATEMENT);
28347         break;
28348       case EACH:
28349         jj_consume_token(EACH);
28350         jj_consume_token(ROW);
28351         break;
28352       default:
28353         jj_la1[437] = jj_gen;
28354         jj_consume_token(-1);
28355         throw new ParseException();
28356       }
28357                                      sb.append(" "); sb.append(token.image) ;
28358       jj_consume_token(IS);
28359       jj_consume_token(BEGIN);
28360       label_100:
28361       while (true) {
28362         Statement();
28363         switch (jj_nt.kind) {
28364         case 5:
28365         case 16:
28366         case 17:
28367         case 21:
28368         case REPLACE:
28369         case DEFINER:
28370         case CURRENT_USER:
28371         case LANGUAGE:
28372         case INLINE:
28373         case ADD:
28374         case AGGREGATE:
28375         case ARRAY:
28376         case AT:
28377         case ATTRIBUTE:
28378         case AUTHID:
28379         case BEGIN:
28380         case BODY:
28381         case BULK:
28382         case BYTE:
28383         case CASCADE:
28384         case CASE:
28385         case CLOSE:
28386         case COALESCE:
28387         case COLLECT:
28388         case COLUMN:
28389         case COMMENT:
28390         case COMMIT:
28391         case CONSTRUCTOR:
28392         case CONTINUE:
28393         case CONVERT:
28394         case CURRENT:
28395         case CURSOR:
28396         case DATA:
28397         case DATE:
28398         case DAY:
28399         case DECLARE:
28400         case DELETE:
28401         case DISABLE:
28402         case EDITIONABLE:
28403         case ELEMENT:
28404         case ENABLE:
28405         case ESCAPE:
28406         case EXCEPT:
28407         case EXCEPTIONS:
28408         case EXECUTE:
28409         case EXIT:
28410         case EXTERNAL:
28411         case EXTENDS:
28412         case EXTRACT:
28413         case FALSE:
28414         case FETCH:
28415         case FINAL:
28416         case FOR:
28417         case FORALL:
28418         case FORCE:
28419         case FUNCTION:
28420         case GLOBAL:
28421         case GOTO:
28422         case HASH:
28423         case HEAP:
28424         case HOUR:
28425         case IF:
28426         case IMMEDIATE:
28427         case INDICES:
28428         case INDEXTYPE:
28429         case INDICATOR:
28430         case INSERT:
28431         case INSTANTIABLE:
28432         case INTERVAL:
28433         case INVALIDATE:
28434         case ISOLATION:
28435         case JAVA:
28436         case LEVEL:
28437         case LIMIT:
28438         case LOCK:
28439         case LOOP:
28440         case MAP:
28441         case MAX:
28442         case MEMBER:
28443         case MERGE:
28444         case MIN:
28445         case MINUTE:
28446         case MLSLABEL:
28447         case MODIFY:
28448         case MOD:
28449         case MONTH:
28450         case NATURAL:
28451         case NEW:
28452         case NEW_DOT:
28453         case NO:
28454         case NONEDITIONABLE:
28455         case NOT:
28456         case NULL:
28457         case NULLIF:
28458         case OBJECT:
28459         case OID:
28460         case OPAQUE:
28461         case OPEN:
28462         case OPERATOR:
28463         case ORGANIZATION:
28464         case OTHERS:
28465         case OVERRIDING:
28466         case PACKAGE:
28467         case PARTITION:
28468         case PIPE:
28469         case PRAGMA:
28470         case PRESERVE:
28471         case PRIVATE:
28472         case PROCEDURE:
28473         case RAISE:
28474         case RANGE:
28475         case RAW:
28476         case REAL:
28477         case RECORD:
28478         case REF:
28479         case RELEASE:
28480         case RELIES_ON:
28481         case RENAME:
28482         case RESULT:
28483         case RETURN:
28484         case RETURNING:
28485         case REVERSE:
28486         case ROLLBACK:
28487         case ROW:
28488         case ROWS:
28489         case ROWID:
28490         case ROWNUM:
28491         case SAVE:
28492         case SAVEPOINT:
28493         case SECOND:
28494         case SELECT:
28495         case SELF:
28496         case SET:
28497         case SPACE:
28498         case SQL:
28499         case SQLCODE:
28500         case SQLERRM:
28501         case STATIC:
28502         case SUBTYPE:
28503         case SUBSTITUTABLE:
28504         case SUCCESSFUL:
28505         case SYSDATE:
28506         case SYS_REFCURSOR:
28507         case TEMPORARY:
28508         case TIME:
28509         case TIMESTAMP:
28510         case TIMEZONE_REGION:
28511         case TIMEZONE_ABBR:
28512         case TIMEZONE_MINUTE:
28513         case TIMEZONE_HOUR:
28514         case TRANSACTION:
28515         case TRUE:
28516         case TYPE:
28517         case UNDER:
28518         case USING:
28519         case WHILE:
28520         case YES:
28521         case SHOW:
28522         case A:
28523         case UPDATE:
28524         case DOUBLE:
28525         case DEC:
28526         case PRECISION:
28527         case INT:
28528         case NUMERIC:
28529         case NCHAR:
28530         case NVARCHAR2:
28531         case STRING:
28532         case UROWID:
28533         case VARRAY:
28534         case VARYING:
28535         case BFILE:
28536         case BLOB:
28537         case CLOB:
28538         case NCLOB:
28539         case YEAR:
28540         case LOCAL:
28541         case WITH:
28542         case ZONE:
28543         case CHARACTER:
28544         case AFTER:
28545         case BEFORE:
28546         case OLD:
28547         case PARENT:
28548         case CC_IF:
28549         case CC_ERROR:
28550         case ANALYZE:
28551         case ASSOCIATE:
28552         case AUDIT:
28553         case COMPOUND:
28554         case DATABASE:
28555         case CALL:
28556         case DDL:
28557         case DISASSOCIATE:
28558         case EACH:
28559         case FOLLOWS:
28560         case LOGOFF:
28561         case LOGON:
28562         case NESTED:
28563         case NOAUDIT:
28564         case SCHEMA:
28565         case SERVERERROR:
28566         case SHUTDOWN:
28567         case STARTUP:
28568         case STATEMENT:
28569         case STATISTICS:
28570         case SUSPEND:
28571         case TRUNCATE:
28572         case WRAPPED:
28573         case LIBRARY:
28574         case NAME:
28575         case STRUCT:
28576         case CONTEXT:
28577         case PARAMETERS:
28578         case LENGTH:
28579         case TDO:
28580         case MAXLEN:
28581         case CHARSETID:
28582         case CHARSETFORM:
28583         case ACCEPT:
28584         case ACCESSIBLE:
28585         case COPY:
28586         case DEFINE:
28587         case DISCONNECT:
28588         case HOST:
28589         case PRINT:
28590         case QUIT:
28591         case REMARK:
28592         case UNDEFINE:
28593         case VARIABLE:
28594         case WHENEVER:
28595         case ATTACH:
28596         case CAST:
28597         case TREAT:
28598         case TRIM:
28599         case LEFT:
28600         case RIGHT:
28601         case BOTH:
28602         case EMPTY:
28603         case MULTISET:
28604         case SUBMULTISET:
28605         case LEADING:
28606         case TRAILING:
28607         case CHAR_CS:
28608         case NCHAR_CS:
28609         case DBTIMEZONE:
28610         case SESSIONTIMEZONE:
28611         case AUTHENTICATED:
28612         case LINK:
28613         case SHARED:
28614         case DIRECTORY:
28615         case USER:
28616         case IDENTIFIER:
28617         case UNSIGNED_NUMERIC_LITERAL:
28618         case CHARACTER_LITERAL:
28619         case STRING_LITERAL:
28620         case QUOTED_LITERAL:
28621           ;
28622           break;
28623         default:
28624           jj_la1[438] = jj_gen;
28625           break label_100;
28626         }
28627       }
28628       jj_consume_token(END);
28629       switch (jj_nt.kind) {
28630       case BEFORE:
28631         jj_consume_token(BEFORE);
28632         break;
28633       case AFTER:
28634         jj_consume_token(AFTER);
28635         break;
28636       case INSTEADOF:
28637         jj_consume_token(INSTEADOF);
28638         break;
28639       default:
28640         jj_la1[439] = jj_gen;
28641         jj_consume_token(-1);
28642         throw new ParseException();
28643       }
28644       switch (jj_nt.kind) {
28645       case STATEMENT:
28646         jj_consume_token(STATEMENT);
28647         break;
28648       case EACH:
28649         jj_consume_token(EACH);
28650         jj_consume_token(ROW);
28651         break;
28652       default:
28653         jj_la1[440] = jj_gen;
28654         jj_consume_token(-1);
28655         throw new ParseException();
28656       }
28657       jj_consume_token(4);
28658 
28659    jjtree.closeNodeScope(jjtn000, true);
28660    jjtc000 = false;
28661    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
28662     } catch (Throwable jjte000) {
28663    if (jjtc000) {
28664      jjtree.clearNodeScope(jjtn000);
28665      jjtc000 = false;
28666    } else {
28667      jjtree.popNode();
28668    }
28669    if (jjte000 instanceof RuntimeException) {
28670      {if (true) throw (RuntimeException)jjte000;}
28671    }
28672    if (jjte000 instanceof ParseException) {
28673      {if (true) throw (ParseException)jjte000;}
28674    }
28675    {if (true) throw (Error)jjte000;}
28676     } finally {
28677    if (jjtc000) {
28678      jjtree.closeNodeScope(jjtn000, true);
28679    }
28680     }
28681     throw new Error("Missing return statement in function");
28682   }
28683 
28684   final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28685  /*@bgen(jjtree) CompoundTriggerBlock */
28686   ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28687   boolean jjtc000 = true;
28688   jjtree.openNodeScope(jjtn000);
28689     try {
28690       jj_consume_token(COMPOUND);
28691       jj_consume_token(TRIGGER);
28692       label_101:
28693       while (true) {
28694         switch (jj_nt.kind) {
28695         case REPLACE:
28696         case DEFINER:
28697         case CURRENT_USER:
28698         case SERIALLY_REUSABLE:
28699         case RESTRICT_REFERENCES:
28700         case EXCEPTION_INIT:
28701         case AUTONOMOUS_TRANSACTION:
28702         case LANGUAGE:
28703         case INLINE:
28704         case ADD:
28705         case AGGREGATE:
28706         case ALL:
28707         case ALTER:
28708         case AND:
28709         case ANY:
28710         case ARRAY:
28711         case AS:
28712         case ASC:
28713         case AT:
28714         case ATTRIBUTE:
28715         case AUTHID:
28716         case AVG:
28717         case BETWEEN:
28718         case BINARY_INTEGER:
28719         case BODY:
28720         case BOOLEAN:
28721         case BULK:
28722         case BY:
28723         case BYTE:
28724         case CASCADE:
28725         case CASE:
28726         case CHAR:
28727         case CHAR_BASE:
28728         case CHECK:
28729         case CLOSE:
28730         case CLUSTER:
28731         case COALESCE:
28732         case COLLECT:
28733         case COLUMN:
28734         case COMMENT:
28735         case COMMIT:
28736         case COMPRESS:
28737         case CONNECT:
28738         case CONSTANT:
28739         case CONSTRUCTOR:
28740         case CONTINUE:
28741         case CONVERT:
28742         case CREATE:
28743         case CURRENT:
28744         case CURRVAL:
28745         case CURSOR:
28746         case DATA:
28747         case DATE:
28748         case DAY:
28749         case DECLARE:
28750         case DECIMAL:
28751         case _DEFAULT:
28752         case DELETE:
28753         case DESC:
28754         case DISABLE:
28755         case DISTINCT:
28756         case DO:
28757         case DROP:
28758         case EDITIONABLE:
28759         case ELEMENT:
28760         case ELSE:
28761         case ELSIF:
28762         case ENABLE:
28763         case ESCAPE:
28764         case EXCEPT:
28765         case EXCEPTION:
28766         case EXCEPTIONS:
28767         case EXCLUSIVE:
28768         case EXECUTE:
28769         case EXISTS:
28770         case EXIT:
28771         case EXTERNAL:
28772         case EXTENDS:
28773         case EXTRACT:
28774         case FALSE:
28775         case FETCH:
28776         case FINAL:
28777         case FLOAT:
28778         case FOR:
28779         case FORALL:
28780         case FORCE:
28781         case FROM:
28782         case FUNCTION:
28783         case GLOBAL:
28784         case GOTO:
28785         case GROUP:
28786         case HASH:
28787         case HAVING:
28788         case HEAP:
28789         case HOUR:
28790         case IF:
28791         case IMMEDIATE:
28792         case IN:
28793         case INDEX:
28794         case INDICES:
28795         case INDEXTYPE:
28796         case INDICATOR:
28797         case INSERT:
28798         case INSTANTIABLE:
28799         case INTEGER:
28800         case INTERFACE:
28801         case INTERSECT:
28802         case INTERVAL:
28803         case INTO:
28804         case INVALIDATE:
28805         case IS:
28806         case ISOLATION:
28807         case JAVA:
28808         case LEVEL:
28809         case LIKE:
28810         case LIMIT:
28811         case LIMITED:
28812         case LOCK:
28813         case LONG:
28814         case LOOP:
28815         case MAP:
28816         case MAX:
28817         case MEMBER:
28818         case MERGE:
28819         case MIN:
28820         case MINUS:
28821         case MINUTE:
28822         case MLSLABEL:
28823         case MODIFY:
28824         case MOD:
28825         case MODE:
28826         case MONTH:
28827         case NATURAL:
28828         case NATURALN:
28829         case NEW:
28830         case NEXTVAL:
28831         case NO:
28832         case NOCOPY:
28833         case NONEDITIONABLE:
28834         case NOT:
28835         case NOWAIT:
28836         case NULL:
28837         case NULLIF:
28838         case NUMBER:
28839         case BFILE_BASE:
28840         case BLOB_BASE:
28841         case CLOB_BASE:
28842         case DATE_BASE:
28843         case NUMBER_BASE:
28844         case OBJECT:
28845         case OCIROWID:
28846         case OF:
28847         case OID:
28848         case ON:
28849         case OPAQUE:
28850         case OPEN:
28851         case OPERATOR:
28852         case OPTION:
28853         case OR:
28854         case ORDER:
28855         case ORGANIZATION:
28856         case OTHERS:
28857         case OUT:
28858         case OVERRIDING:
28859         case PACKAGE:
28860         case PARTITION:
28861         case PCTFREE:
28862         case PLS_INTEGER:
28863         case POSITIVE:
28864         case POSITIVEN:
28865         case PRAGMA:
28866         case PRESERVE:
28867         case PRIOR:
28868         case PROMPT:
28869         case PRIVATE:
28870         case PROCEDURE:
28871         case PUBLIC:
28872         case RAISE:
28873         case RANGE:
28874         case RAW:
28875         case REAL:
28876         case RECORD:
28877         case REF:
28878         case RELEASE:
28879         case RELIES_ON:
28880         case RENAME:
28881         case RESULT:
28882         case RETURN:
28883         case RETURNING:
28884         case REVERSE:
28885         case ROLLBACK:
28886         case ROW:
28887         case ROWS:
28888         case ROWID:
28889         case ROWNUM:
28890         case ROWTYPE:
28891         case SAVE:
28892         case SAVEPOINT:
28893         case SECOND:
28894         case SELECT:
28895         case SELF:
28896         case SEPARATE:
28897         case SET:
28898         case SHARE:
28899         case SMALLINT:
28900         case SPACE:
28901         case SQL:
28902         case SQLCODE:
28903         case SQLERRM:
28904         case START:
28905         case STATIC:
28906         case STDDEV:
28907         case SUBTYPE:
28908         case SUBSTITUTABLE:
28909         case SUCCESSFUL:
28910         case SUM:
28911         case SYNONYM:
28912         case SYSDATE:
28913         case SYS_REFCURSOR:
28914         case TABLE:
28915         case TEMPORARY:
28916         case THEN:
28917         case TIME:
28918         case TIMESTAMP:
28919         case TIMEZONE_REGION:
28920         case TIMEZONE_ABBR:
28921         case TIMEZONE_MINUTE:
28922         case TIMEZONE_HOUR:
28923         case TO:
28924         case TRANSACTION:
28925         case TRIGGER:
28926         case TRUE:
28927         case TYPE:
28928         case UI:
28929         case UNDER:
28930         case USING:
28931         case WHILE:
28932         case YES:
28933         case SHOW:
28934         case A:
28935         case UPDATE:
28936         case VARCHAR:
28937         case VARCHAR2:
28938         case DOUBLE:
28939         case DEC:
28940         case PRECISION:
28941         case INT:
28942         case NUMERIC:
28943         case SIGNTYPE:
28944         case NCHAR:
28945         case NVARCHAR2:
28946         case STRING:
28947         case UROWID:
28948         case VARRAY:
28949         case VARYING:
28950         case BFILE:
28951         case BLOB:
28952         case CLOB:
28953         case NCLOB:
28954         case YEAR:
28955         case LOCAL:
28956         case WITH:
28957         case ZONE:
28958         case CHARACTER:
28959         case AFTER:
28960         case BEFORE:
28961         case INSTEADOF:
28962         case OLD:
28963         case PARENT:
28964         case ANALYZE:
28965         case ASSOCIATE:
28966         case AUDIT:
28967         case COMPOUND:
28968         case DATABASE:
28969         case CALL:
28970         case DDL:
28971         case DISASSOCIATE:
28972         case EACH:
28973         case FOLLOWS:
28974         case LOGOFF:
28975         case LOGON:
28976         case NESTED:
28977         case NOAUDIT:
28978         case SCHEMA:
28979         case SERVERERROR:
28980         case SHUTDOWN:
28981         case STARTUP:
28982         case STATEMENT:
28983         case STATISTICS:
28984         case SUSPEND:
28985         case TRUNCATE:
28986         case WRAPPED:
28987         case LIBRARY:
28988         case NAME:
28989         case STRUCT:
28990         case CONTEXT:
28991         case PARAMETERS:
28992         case LENGTH:
28993         case TDO:
28994         case MAXLEN:
28995         case CHARSETID:
28996         case CHARSETFORM:
28997         case ACCEPT:
28998         case ACCESSIBLE:
28999         case COPY:
29000         case DEFINE:
29001         case DISCONNECT:
29002         case HOST:
29003         case PRINT:
29004         case QUIT:
29005         case REMARK:
29006         case UNDEFINE:
29007         case VARIABLE:
29008         case WHENEVER:
29009         case ATTACH:
29010         case CAST:
29011         case TREAT:
29012         case TRIM:
29013         case LEFT:
29014         case RIGHT:
29015         case BOTH:
29016         case EMPTY:
29017         case MULTISET:
29018         case SUBMULTISET:
29019         case LEADING:
29020         case TRAILING:
29021         case CHAR_CS:
29022         case NCHAR_CS:
29023         case DBTIMEZONE:
29024         case SESSIONTIMEZONE:
29025         case AUTHENTICATED:
29026         case LINK:
29027         case SHARED:
29028         case DIRECTORY:
29029         case USER:
29030         case IDENTIFIER:
29031         case QUOTED_LITERAL:
29032         case SQLDATA_CLASS:
29033         case CUSTOMDATUM_CLASS:
29034         case ORADATA_CLASS:
29035         case JAVA_INTERFACE_CLASS:
29036           ;
29037           break;
29038         default:
29039           jj_la1[441] = jj_gen;
29040           break label_101;
29041         }
29042         switch (jj_nt.kind) {
29043         case AFTER:
29044         case BEFORE:
29045         case INSTEADOF:
29046           TriggerTimingPointSection();
29047           break;
29048         case PRAGMA:
29049           Pragma();
29050           break;
29051         default:
29052           jj_la1[442] = jj_gen;
29053           if (jj_2_81(2)) {
29054             ExceptionDeclaration();
29055           } else if (jj_2_82(2)) {
29056             SubTypeDefinition();
29057           } else if (jj_2_83(4)) {
29058             VariableOrConstantDeclaration();
29059           } else if (jj_2_84(2)) {
29060             CursorSpecification();
29061           } else {
29062             switch (jj_nt.kind) {
29063             case CURSOR:
29064               CursorBody();
29065               break;
29066             case IDENTIFIER:
29067               CollectionDeclaration();
29068               break;
29069             case CREATE:
29070             case FUNCTION:
29071             case PROCEDURE:
29072               ProgramUnit();
29073               break;
29074             default:
29075               jj_la1[443] = jj_gen;
29076               jj_consume_token(-1);
29077               throw new ParseException();
29078             }
29079           }
29080         }
29081       }
29082       jj_consume_token(END);
29083       switch (jj_nt.kind) {
29084       case REPLACE:
29085       case DEFINER:
29086       case CURRENT_USER:
29087       case SERIALLY_REUSABLE:
29088       case RESTRICT_REFERENCES:
29089       case EXCEPTION_INIT:
29090       case AUTONOMOUS_TRANSACTION:
29091       case LANGUAGE:
29092       case INLINE:
29093       case ADD:
29094       case AGGREGATE:
29095       case ALL:
29096       case ALTER:
29097       case AND:
29098       case ANY:
29099       case ARRAY:
29100       case AS:
29101       case ASC:
29102       case AT:
29103       case ATTRIBUTE:
29104       case AUTHID:
29105       case AVG:
29106       case BETWEEN:
29107       case BINARY_INTEGER:
29108       case BODY:
29109       case BOOLEAN:
29110       case BULK:
29111       case BY:
29112       case BYTE:
29113       case CASCADE:
29114       case CASE:
29115       case CHAR:
29116       case CHAR_BASE:
29117       case CHECK:
29118       case CLOSE:
29119       case CLUSTER:
29120       case COALESCE:
29121       case COLLECT:
29122       case COLUMN:
29123       case COMMENT:
29124       case COMMIT:
29125       case COMPRESS:
29126       case CONNECT:
29127       case CONSTANT:
29128       case CONSTRUCTOR:
29129       case CONTINUE:
29130       case CONVERT:
29131       case CREATE:
29132       case CURRENT:
29133       case CURRVAL:
29134       case CURSOR:
29135       case DATA:
29136       case DATE:
29137       case DAY:
29138       case DECLARE:
29139       case DECIMAL:
29140       case _DEFAULT:
29141       case DELETE:
29142       case DESC:
29143       case DISABLE:
29144       case DISTINCT:
29145       case DO:
29146       case DROP:
29147       case EDITIONABLE:
29148       case ELEMENT:
29149       case ELSE:
29150       case ELSIF:
29151       case ENABLE:
29152       case ESCAPE:
29153       case EXCEPT:
29154       case EXCEPTION:
29155       case EXCEPTIONS:
29156       case EXCLUSIVE:
29157       case EXECUTE:
29158       case EXISTS:
29159       case EXIT:
29160       case EXTERNAL:
29161       case EXTENDS:
29162       case EXTRACT:
29163       case FALSE:
29164       case FETCH:
29165       case FINAL:
29166       case FLOAT:
29167       case FOR:
29168       case FORALL:
29169       case FORCE:
29170       case FROM:
29171       case FUNCTION:
29172       case GLOBAL:
29173       case GOTO:
29174       case GROUP:
29175       case HASH:
29176       case HAVING:
29177       case HEAP:
29178       case HOUR:
29179       case IF:
29180       case IMMEDIATE:
29181       case IN:
29182       case INDEX:
29183       case INDICES:
29184       case INDEXTYPE:
29185       case INDICATOR:
29186       case INSERT:
29187       case INSTANTIABLE:
29188       case INTEGER:
29189       case INTERFACE:
29190       case INTERSECT:
29191       case INTERVAL:
29192       case INTO:
29193       case INVALIDATE:
29194       case IS:
29195       case ISOLATION:
29196       case JAVA:
29197       case LEVEL:
29198       case LIKE:
29199       case LIMIT:
29200       case LIMITED:
29201       case LOCK:
29202       case LONG:
29203       case LOOP:
29204       case MAP:
29205       case MAX:
29206       case MEMBER:
29207       case MERGE:
29208       case MIN:
29209       case MINUS:
29210       case MINUTE:
29211       case MLSLABEL:
29212       case MODIFY:
29213       case MOD:
29214       case MODE:
29215       case MONTH:
29216       case NATURAL:
29217       case NATURALN:
29218       case NEW:
29219       case NEXTVAL:
29220       case NO:
29221       case NOCOPY:
29222       case NONEDITIONABLE:
29223       case NOT:
29224       case NOWAIT:
29225       case NULL:
29226       case NULLIF:
29227       case NUMBER:
29228       case BFILE_BASE:
29229       case BLOB_BASE:
29230       case CLOB_BASE:
29231       case DATE_BASE:
29232       case NUMBER_BASE:
29233       case OBJECT:
29234       case OCIROWID:
29235       case OF:
29236       case OID:
29237       case ON:
29238       case OPAQUE:
29239       case OPEN:
29240       case OPERATOR:
29241       case OPTION:
29242       case OR:
29243       case ORDER:
29244       case ORGANIZATION:
29245       case OTHERS:
29246       case OUT:
29247       case OVERRIDING:
29248       case PACKAGE:
29249       case PARTITION:
29250       case PCTFREE:
29251       case PLS_INTEGER:
29252       case POSITIVE:
29253       case POSITIVEN:
29254       case PRESERVE:
29255       case PRIOR:
29256       case PROMPT:
29257       case PRIVATE:
29258       case PROCEDURE:
29259       case PUBLIC:
29260       case RAISE:
29261       case RANGE:
29262       case RAW:
29263       case REAL:
29264       case RECORD:
29265       case REF:
29266       case RELEASE:
29267       case RELIES_ON:
29268       case RENAME:
29269       case RESULT:
29270       case RETURN:
29271       case RETURNING:
29272       case REVERSE:
29273       case ROLLBACK:
29274       case ROW:
29275       case ROWS:
29276       case ROWID:
29277       case ROWNUM:
29278       case ROWTYPE:
29279       case SAVE:
29280       case SAVEPOINT:
29281       case SECOND:
29282       case SELECT:
29283       case SELF:
29284       case SEPARATE:
29285       case SET:
29286       case SHARE:
29287       case SMALLINT:
29288       case SPACE:
29289       case SQL:
29290       case SQLCODE:
29291       case SQLERRM:
29292       case START:
29293       case STATIC:
29294       case STDDEV:
29295       case SUBTYPE:
29296       case SUBSTITUTABLE:
29297       case SUCCESSFUL:
29298       case SUM:
29299       case SYNONYM:
29300       case SYSDATE:
29301       case SYS_REFCURSOR:
29302       case TABLE:
29303       case TEMPORARY:
29304       case THEN:
29305       case TIME:
29306       case TIMESTAMP:
29307       case TIMEZONE_REGION:
29308       case TIMEZONE_ABBR:
29309       case TIMEZONE_MINUTE:
29310       case TIMEZONE_HOUR:
29311       case TO:
29312       case TRANSACTION:
29313       case TRIGGER:
29314       case TRUE:
29315       case TYPE:
29316       case UI:
29317       case UNDER:
29318       case USING:
29319       case WHILE:
29320       case YES:
29321       case SHOW:
29322       case A:
29323       case UPDATE:
29324       case VARCHAR:
29325       case VARCHAR2:
29326       case DOUBLE:
29327       case DEC:
29328       case PRECISION:
29329       case INT:
29330       case NUMERIC:
29331       case SIGNTYPE:
29332       case NCHAR:
29333       case NVARCHAR2:
29334       case STRING:
29335       case UROWID:
29336       case VARRAY:
29337       case VARYING:
29338       case BFILE:
29339       case BLOB:
29340       case CLOB:
29341       case NCLOB:
29342       case YEAR:
29343       case LOCAL:
29344       case WITH:
29345       case ZONE:
29346       case CHARACTER:
29347       case AFTER:
29348       case BEFORE:
29349       case OLD:
29350       case PARENT:
29351       case ANALYZE:
29352       case ASSOCIATE:
29353       case AUDIT:
29354       case COMPOUND:
29355       case DATABASE:
29356       case CALL:
29357       case DDL:
29358       case DISASSOCIATE:
29359       case EACH:
29360       case FOLLOWS:
29361       case LOGOFF:
29362       case LOGON:
29363       case NESTED:
29364       case NOAUDIT:
29365       case SCHEMA:
29366       case SERVERERROR:
29367       case SHUTDOWN:
29368       case STARTUP:
29369       case STATEMENT:
29370       case STATISTICS:
29371       case SUSPEND:
29372       case TRUNCATE:
29373       case WRAPPED:
29374       case LIBRARY:
29375       case NAME:
29376       case STRUCT:
29377       case CONTEXT:
29378       case PARAMETERS:
29379       case LENGTH:
29380       case TDO:
29381       case MAXLEN:
29382       case CHARSETID:
29383       case CHARSETFORM:
29384       case ACCEPT:
29385       case ACCESSIBLE:
29386       case COPY:
29387       case DEFINE:
29388       case DISCONNECT:
29389       case HOST:
29390       case PRINT:
29391       case QUIT:
29392       case REMARK:
29393       case UNDEFINE:
29394       case VARIABLE:
29395       case WHENEVER:
29396       case ATTACH:
29397       case CAST:
29398       case TREAT:
29399       case TRIM:
29400       case LEFT:
29401       case RIGHT:
29402       case BOTH:
29403       case EMPTY:
29404       case MULTISET:
29405       case SUBMULTISET:
29406       case LEADING:
29407       case TRAILING:
29408       case CHAR_CS:
29409       case NCHAR_CS:
29410       case DBTIMEZONE:
29411       case SESSIONTIMEZONE:
29412       case AUTHENTICATED:
29413       case LINK:
29414       case SHARED:
29415       case DIRECTORY:
29416       case USER:
29417       case IDENTIFIER:
29418       case QUOTED_LITERAL:
29419       case SQLDATA_CLASS:
29420       case CUSTOMDATUM_CLASS:
29421       case ORADATA_CLASS:
29422       case JAVA_INTERFACE_CLASS:
29423         ID();
29424         break;
29425       default:
29426         jj_la1[444] = jj_gen;
29427         ;
29428       }
29429       jj_consume_token(4);
29430         jjtree.closeNodeScope(jjtn000, true);
29431         jjtc000 = false;
29432         {if (true) return jjtn000 ;}
29433     } catch (Throwable jjte000) {
29434     if (jjtc000) {
29435       jjtree.clearNodeScope(jjtn000);
29436       jjtc000 = false;
29437     } else {
29438       jjtree.popNode();
29439     }
29440     if (jjte000 instanceof RuntimeException) {
29441       {if (true) throw (RuntimeException)jjte000;}
29442     }
29443     if (jjte000 instanceof ParseException) {
29444       {if (true) throw (ParseException)jjte000;}
29445     }
29446     {if (true) throw (Error)jjte000;}
29447     } finally {
29448     if (jjtc000) {
29449       jjtree.closeNodeScope(jjtn000, true);
29450     }
29451     }
29452     throw new Error("Missing return statement in function");
29453   }
29454 
29455 /*
29456 non_dml_trigger :
29457 (BEFORE> |<AFTER> ) 
29458 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
29459 ON
29460 (DATABASE | [schema.]SCHEMA
29461 */
29462   final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29463  /*@bgen(jjtree) NonDMLTrigger */
29464   ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29465   boolean jjtc000 = true;
29466   jjtree.openNodeScope(jjtn000);
29467     try {
29468       switch (jj_nt.kind) {
29469       case BEFORE:
29470         jj_consume_token(BEFORE);
29471         break;
29472       case AFTER:
29473         jj_consume_token(AFTER);
29474         break;
29475       default:
29476         jj_la1[445] = jj_gen;
29477         jj_consume_token(-1);
29478         throw new ParseException();
29479       }
29480       switch (jj_nt.kind) {
29481       case ALTER:
29482       case COMMENT:
29483       case CREATE:
29484       case DROP:
29485       case GRANT:
29486       case RENAME:
29487       case REVOKE:
29488       case ANALYZE:
29489       case ASSOCIATE:
29490       case AUDIT:
29491       case DDL:
29492       case DISASSOCIATE:
29493       case NOAUDIT:
29494       case TRUNCATE:
29495         DDLEvent();
29496         break;
29497       case LOGOFF:
29498       case LOGON:
29499       case SERVERERROR:
29500       case SHUTDOWN:
29501       case STARTUP:
29502       case SUSPEND:
29503         DatabaseEvent();
29504         break;
29505       default:
29506         jj_la1[446] = jj_gen;
29507         jj_consume_token(-1);
29508         throw new ParseException();
29509       }
29510       label_102:
29511       while (true) {
29512         switch (jj_nt.kind) {
29513         case OR:
29514           ;
29515           break;
29516         default:
29517           jj_la1[447] = jj_gen;
29518           break label_102;
29519         }
29520         jj_consume_token(OR);
29521         switch (jj_nt.kind) {
29522         case ALTER:
29523         case COMMENT:
29524         case CREATE:
29525         case DROP:
29526         case GRANT:
29527         case RENAME:
29528         case REVOKE:
29529         case ANALYZE:
29530         case ASSOCIATE:
29531         case AUDIT:
29532         case DDL:
29533         case DISASSOCIATE:
29534         case NOAUDIT:
29535         case TRUNCATE:
29536           DDLEvent();
29537           break;
29538         case LOGOFF:
29539         case LOGON:
29540         case SERVERERROR:
29541         case SHUTDOWN:
29542         case STARTUP:
29543         case SUSPEND:
29544           DatabaseEvent();
29545           break;
29546         default:
29547           jj_la1[448] = jj_gen;
29548           jj_consume_token(-1);
29549           throw new ParseException();
29550         }
29551       }
29552       jj_consume_token(ON);
29553       switch (jj_nt.kind) {
29554       case DATABASE:
29555         jj_consume_token(DATABASE);
29556         break;
29557       case REPLACE:
29558       case DEFINER:
29559       case CURRENT_USER:
29560       case SERIALLY_REUSABLE:
29561       case RESTRICT_REFERENCES:
29562       case EXCEPTION_INIT:
29563       case AUTONOMOUS_TRANSACTION:
29564       case LANGUAGE:
29565       case INLINE:
29566       case ADD:
29567       case AGGREGATE:
29568       case ALL:
29569       case ALTER:
29570       case AND:
29571       case ANY:
29572       case ARRAY:
29573       case AS:
29574       case ASC:
29575       case AT:
29576       case ATTRIBUTE:
29577       case AUTHID:
29578       case AVG:
29579       case BETWEEN:
29580       case BINARY_INTEGER:
29581       case BODY:
29582       case BOOLEAN:
29583       case BULK:
29584       case BY:
29585       case BYTE:
29586       case CASCADE:
29587       case CASE:
29588       case CHAR:
29589       case CHAR_BASE:
29590       case CHECK:
29591       case CLOSE:
29592       case CLUSTER:
29593       case COALESCE:
29594       case COLLECT:
29595       case COLUMN:
29596       case COMMENT:
29597       case COMMIT:
29598       case COMPRESS:
29599       case CONNECT:
29600       case CONSTANT:
29601       case CONSTRUCTOR:
29602       case CONTINUE:
29603       case CONVERT:
29604       case CREATE:
29605       case CURRENT:
29606       case CURRVAL:
29607       case CURSOR:
29608       case DATA:
29609       case DATE:
29610       case DAY:
29611       case DECLARE:
29612       case DECIMAL:
29613       case _DEFAULT:
29614       case DELETE:
29615       case DESC:
29616       case DISABLE:
29617       case DISTINCT:
29618       case DO:
29619       case DROP:
29620       case EDITIONABLE:
29621       case ELEMENT:
29622       case ELSE:
29623       case ELSIF:
29624       case ENABLE:
29625       case ESCAPE:
29626       case EXCEPT:
29627       case EXCEPTION:
29628       case EXCEPTIONS:
29629       case EXCLUSIVE:
29630       case EXECUTE:
29631       case EXISTS:
29632       case EXIT:
29633       case EXTERNAL:
29634       case EXTENDS:
29635       case EXTRACT:
29636       case FALSE:
29637       case FETCH:
29638       case FINAL:
29639       case FLOAT:
29640       case FOR:
29641       case FORALL:
29642       case FORCE:
29643       case FROM:
29644       case FUNCTION:
29645       case GLOBAL:
29646       case GOTO:
29647       case GROUP:
29648       case HASH:
29649       case HAVING:
29650       case HEAP:
29651       case HOUR:
29652       case IF:
29653       case IMMEDIATE:
29654       case IN:
29655       case INDEX:
29656       case INDICES:
29657       case INDEXTYPE:
29658       case INDICATOR:
29659       case INSERT:
29660       case INSTANTIABLE:
29661       case INTEGER:
29662       case INTERFACE:
29663       case INTERSECT:
29664       case INTERVAL:
29665       case INTO:
29666       case INVALIDATE:
29667       case IS:
29668       case ISOLATION:
29669       case JAVA:
29670       case LEVEL:
29671       case LIKE:
29672       case LIMIT:
29673       case LIMITED:
29674       case LOCK:
29675       case LONG:
29676       case LOOP:
29677       case MAP:
29678       case MAX:
29679       case MEMBER:
29680       case MERGE:
29681       case MIN:
29682       case MINUS:
29683       case MINUTE:
29684       case MLSLABEL:
29685       case MODIFY:
29686       case MOD:
29687       case MODE:
29688       case MONTH:
29689       case NATURAL:
29690       case NATURALN:
29691       case NEW:
29692       case NEXTVAL:
29693       case NO:
29694       case NOCOPY:
29695       case NONEDITIONABLE:
29696       case NOT:
29697       case NOWAIT:
29698       case NULL:
29699       case NULLIF:
29700       case NUMBER:
29701       case BFILE_BASE:
29702       case BLOB_BASE:
29703       case CLOB_BASE:
29704       case DATE_BASE:
29705       case NUMBER_BASE:
29706       case OBJECT:
29707       case OCIROWID:
29708       case OF:
29709       case OID:
29710       case ON:
29711       case OPAQUE:
29712       case OPEN:
29713       case OPERATOR:
29714       case OPTION:
29715       case OR:
29716       case ORDER:
29717       case ORGANIZATION:
29718       case OTHERS:
29719       case OUT:
29720       case OVERRIDING:
29721       case PACKAGE:
29722       case PARTITION:
29723       case PCTFREE:
29724       case PLS_INTEGER:
29725       case POSITIVE:
29726       case POSITIVEN:
29727       case PRESERVE:
29728       case PRIOR:
29729       case PROMPT:
29730       case PRIVATE:
29731       case PROCEDURE:
29732       case PUBLIC:
29733       case RAISE:
29734       case RANGE:
29735       case RAW:
29736       case REAL:
29737       case RECORD:
29738       case REF:
29739       case RELEASE:
29740       case RELIES_ON:
29741       case RENAME:
29742       case RESULT:
29743       case RETURN:
29744       case RETURNING:
29745       case REVERSE:
29746       case ROLLBACK:
29747       case ROW:
29748       case ROWS:
29749       case ROWID:
29750       case ROWNUM:
29751       case ROWTYPE:
29752       case SAVE:
29753       case SAVEPOINT:
29754       case SECOND:
29755       case SELECT:
29756       case SELF:
29757       case SEPARATE:
29758       case SET:
29759       case SHARE:
29760       case SMALLINT:
29761       case SPACE:
29762       case SQL:
29763       case SQLCODE:
29764       case SQLERRM:
29765       case START:
29766       case STATIC:
29767       case STDDEV:
29768       case SUBTYPE:
29769       case SUBSTITUTABLE:
29770       case SUCCESSFUL:
29771       case SUM:
29772       case SYNONYM:
29773       case SYSDATE:
29774       case SYS_REFCURSOR:
29775       case TABLE:
29776       case TEMPORARY:
29777       case THEN:
29778       case TIME:
29779       case TIMESTAMP:
29780       case TIMEZONE_REGION:
29781       case TIMEZONE_ABBR:
29782       case TIMEZONE_MINUTE:
29783       case TIMEZONE_HOUR:
29784       case TO:
29785       case TRANSACTION:
29786       case TRIGGER:
29787       case TRUE:
29788       case TYPE:
29789       case UI:
29790       case UNDER:
29791       case USING:
29792       case WHILE:
29793       case YES:
29794       case SHOW:
29795       case A:
29796       case UPDATE:
29797       case VARCHAR:
29798       case VARCHAR2:
29799       case DOUBLE:
29800       case DEC:
29801       case PRECISION:
29802       case INT:
29803       case NUMERIC:
29804       case SIGNTYPE:
29805       case NCHAR:
29806       case NVARCHAR2:
29807       case STRING:
29808       case UROWID:
29809       case VARRAY:
29810       case VARYING:
29811       case BFILE:
29812       case BLOB:
29813       case CLOB:
29814       case NCLOB:
29815       case YEAR:
29816       case LOCAL:
29817       case WITH:
29818       case ZONE:
29819       case CHARACTER:
29820       case AFTER:
29821       case BEFORE:
29822       case OLD:
29823       case PARENT:
29824       case ANALYZE:
29825       case ASSOCIATE:
29826       case AUDIT:
29827       case COMPOUND:
29828       case CALL:
29829       case DDL:
29830       case DISASSOCIATE:
29831       case EACH:
29832       case FOLLOWS:
29833       case LOGOFF:
29834       case LOGON:
29835       case NESTED:
29836       case NOAUDIT:
29837       case SCHEMA:
29838       case SERVERERROR:
29839       case SHUTDOWN:
29840       case STARTUP:
29841       case STATEMENT:
29842       case STATISTICS:
29843       case SUSPEND:
29844       case TRUNCATE:
29845       case WRAPPED:
29846       case LIBRARY:
29847       case NAME:
29848       case STRUCT:
29849       case CONTEXT:
29850       case PARAMETERS:
29851       case LENGTH:
29852       case TDO:
29853       case MAXLEN:
29854       case CHARSETID:
29855       case CHARSETFORM:
29856       case ACCEPT:
29857       case ACCESSIBLE:
29858       case COPY:
29859       case DEFINE:
29860       case DISCONNECT:
29861       case HOST:
29862       case PRINT:
29863       case QUIT:
29864       case REMARK:
29865       case UNDEFINE:
29866       case VARIABLE:
29867       case WHENEVER:
29868       case ATTACH:
29869       case CAST:
29870       case TREAT:
29871       case TRIM:
29872       case LEFT:
29873       case RIGHT:
29874       case BOTH:
29875       case EMPTY:
29876       case MULTISET:
29877       case SUBMULTISET:
29878       case LEADING:
29879       case TRAILING:
29880       case CHAR_CS:
29881       case NCHAR_CS:
29882       case DBTIMEZONE:
29883       case SESSIONTIMEZONE:
29884       case AUTHENTICATED:
29885       case LINK:
29886       case SHARED:
29887       case DIRECTORY:
29888       case USER:
29889       case IDENTIFIER:
29890       case QUOTED_LITERAL:
29891       case SQLDATA_CLASS:
29892       case CUSTOMDATUM_CLASS:
29893       case ORADATA_CLASS:
29894       case JAVA_INTERFACE_CLASS:
29895         if (jj_2_85(2)) {
29896           ID();
29897           jj_consume_token(3);
29898         } else {
29899           ;
29900         }
29901         jj_consume_token(SCHEMA);
29902         break;
29903       default:
29904         jj_la1[449] = jj_gen;
29905         jj_consume_token(-1);
29906         throw new ParseException();
29907       }
29908         jjtree.closeNodeScope(jjtn000, true);
29909         jjtc000 = false;
29910         {if (true) return jjtn000 ;}
29911     } catch (Throwable jjte000) {
29912    if (jjtc000) {
29913      jjtree.clearNodeScope(jjtn000);
29914      jjtc000 = false;
29915    } else {
29916      jjtree.popNode();
29917    }
29918    if (jjte000 instanceof RuntimeException) {
29919      {if (true) throw (RuntimeException)jjte000;}
29920    }
29921    if (jjte000 instanceof ParseException) {
29922      {if (true) throw (ParseException)jjte000;}
29923    }
29924    {if (true) throw (Error)jjte000;}
29925     } finally {
29926    if (jjtc000) {
29927      jjtree.closeNodeScope(jjtn000, true);
29928    }
29929     }
29930     throw new Error("Missing return statement in function");
29931   }
29932 
29933   final public ASTDDLEvent DDLEvent() throws ParseException {
29934                          /*@bgen(jjtree) DDLEvent */
29935   ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29936   boolean jjtc000 = true;
29937   jjtree.openNodeScope(jjtn000);
29938     try {
29939       switch (jj_nt.kind) {
29940       case ALTER:
29941         jj_consume_token(ALTER);
29942         break;
29943       case ANALYZE:
29944         jj_consume_token(ANALYZE);
29945         break;
29946       case ASSOCIATE:
29947         jj_consume_token(ASSOCIATE);
29948         jj_consume_token(STATISTICS);
29949         break;
29950       case AUDIT:
29951         jj_consume_token(AUDIT);
29952         break;
29953       case COMMENT:
29954         jj_consume_token(COMMENT);
29955         break;
29956       case CREATE:
29957         jj_consume_token(CREATE);
29958         break;
29959       case DISASSOCIATE:
29960         jj_consume_token(DISASSOCIATE);
29961         jj_consume_token(STATISTICS);
29962         break;
29963       case DROP:
29964         jj_consume_token(DROP);
29965         break;
29966       case GRANT:
29967         jj_consume_token(GRANT);
29968         break;
29969       case NOAUDIT:
29970         jj_consume_token(NOAUDIT);
29971         break;
29972       case RENAME:
29973         jj_consume_token(RENAME);
29974         break;
29975       case REVOKE:
29976         jj_consume_token(REVOKE);
29977         break;
29978       case TRUNCATE:
29979         jj_consume_token(TRUNCATE);
29980         break;
29981       case DDL:
29982         jj_consume_token(DDL);
29983         break;
29984       default:
29985         jj_la1[450] = jj_gen;
29986         jj_consume_token(-1);
29987         throw new ParseException();
29988       }
29989           jjtree.closeNodeScope(jjtn000, true);
29990           jjtc000 = false;
29991           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29992     } finally {
29993     if (jjtc000) {
29994       jjtree.closeNodeScope(jjtn000, true);
29995     }
29996     }
29997     throw new Error("Missing return statement in function");
29998   }
29999 
30000   final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
30001                                    /*@bgen(jjtree) DatabaseEvent */
30002   ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
30003   boolean jjtc000 = true;
30004   jjtree.openNodeScope(jjtn000);
30005     try {
30006       switch (jj_nt.kind) {
30007       case STARTUP:
30008         jj_consume_token(STARTUP);
30009         break;
30010       case SHUTDOWN:
30011         jj_consume_token(SHUTDOWN);
30012         break;
30013       case LOGON:
30014         jj_consume_token(LOGON);
30015         break;
30016       case LOGOFF:
30017         jj_consume_token(LOGOFF);
30018         break;
30019       case SERVERERROR:
30020         jj_consume_token(SERVERERROR);
30021         break;
30022       case SUSPEND:
30023         jj_consume_token(SUSPEND);
30024         break;
30025       default:
30026         jj_la1[451] = jj_gen;
30027         jj_consume_token(-1);
30028         throw new ParseException();
30029       }
30030           jjtree.closeNodeScope(jjtn000, true);
30031           jjtc000 = false;
30032           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30033     } finally {
30034     if (jjtc000) {
30035       jjtree.closeNodeScope(jjtn000, true);
30036     }
30037     }
30038     throw new Error("Missing return statement in function");
30039   }
30040 
30041   final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
30042                                /*@bgen(jjtree) NonDMLEvent */
30043   ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
30044   boolean jjtc000 = true;
30045   jjtree.openNodeScope(jjtn000);
30046     try {
30047       switch (jj_nt.kind) {
30048       case ALTER:
30049       case COMMENT:
30050       case CREATE:
30051       case DROP:
30052       case GRANT:
30053       case RENAME:
30054       case REVOKE:
30055       case ANALYZE:
30056       case ASSOCIATE:
30057       case AUDIT:
30058       case DDL:
30059       case DISASSOCIATE:
30060       case NOAUDIT:
30061       case TRUNCATE:
30062         DDLEvent();
30063         break;
30064       case LOGOFF:
30065       case LOGON:
30066       case SERVERERROR:
30067       case SHUTDOWN:
30068       case STARTUP:
30069       case SUSPEND:
30070         DatabaseEvent();
30071         break;
30072       default:
30073         jj_la1[452] = jj_gen;
30074         jj_consume_token(-1);
30075         throw new ParseException();
30076       }
30077     jjtree.closeNodeScope(jjtn000, true);
30078     jjtc000 = false;
30079     {if (true) return jjtn000;}
30080     } catch (Throwable jjte000) {
30081     if (jjtc000) {
30082       jjtree.clearNodeScope(jjtn000);
30083       jjtc000 = false;
30084     } else {
30085       jjtree.popNode();
30086     }
30087     if (jjte000 instanceof RuntimeException) {
30088       {if (true) throw (RuntimeException)jjte000;}
30089     }
30090     if (jjte000 instanceof ParseException) {
30091       {if (true) throw (ParseException)jjte000;}
30092     }
30093     {if (true) throw (Error)jjte000;}
30094     } finally {
30095     if (jjtc000) {
30096       jjtree.closeNodeScope(jjtn000, true);
30097     }
30098     }
30099     throw new Error("Missing return statement in function");
30100   }
30101 
30102 /*
30103 When DBMS_METADATA.GET_DDL returns a trigger, it can come in 2 DDL statements.
30104 The first is the CREATE OR REPLACE TRIGER statement; the second is an ALTER TRIGGER statement,
30105 enabling or disabling the trigger.
30106 
30107 Unlike the ALTER TYPE, it does not seem to alter the structure of the object.
30108 */
30109   final public void AlterTrigger() throws ParseException {
30110  /*@bgen(jjtree) AlterTrigger */
30111   ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
30112   boolean jjtc000 = true;
30113   jjtree.openNodeScope(jjtn000);
30114     try {
30115       jj_consume_token(ALTER);
30116       jj_consume_token(TRIGGER);
30117       Skip2NextTerminator(null,";");
30118       jj_consume_token(4);
30119           jjtree.closeNodeScope(jjtn000, true);
30120           jjtc000 = false;
30121                 {if (true) return;}
30122     } catch (Throwable jjte000) {
30123           if (jjtc000) {
30124             jjtree.clearNodeScope(jjtn000);
30125             jjtc000 = false;
30126           } else {
30127             jjtree.popNode();
30128           }
30129           if (jjte000 instanceof RuntimeException) {
30130             {if (true) throw (RuntimeException)jjte000;}
30131           }
30132           if (jjte000 instanceof ParseException) {
30133             {if (true) throw (ParseException)jjte000;}
30134           }
30135           {if (true) throw (Error)jjte000;}
30136     } finally {
30137           if (jjtc000) {
30138             jjtree.closeNodeScope(jjtn000, true);
30139           }
30140     }
30141   }
30142 
30143 //SRT 2011-04-17 - START 
30144   final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
30145                                           /*@bgen(jjtree) KEYWORD_RESERVED */
30146   ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
30147   boolean jjtc000 = true;
30148   jjtree.openNodeScope(jjtn000);
30149     try {
30150       switch (jj_nt.kind) {
30151       case ALL:
30152         jj_consume_token(ALL);
30153         break;
30154       case ALTER:
30155         jj_consume_token(ALTER);
30156         break;
30157       case AND:
30158         jj_consume_token(AND);
30159         break;
30160       case ANY:
30161         jj_consume_token(ANY);
30162         break;
30163       case AS:
30164         jj_consume_token(AS);
30165         break;
30166       case ASC:
30167         jj_consume_token(ASC);
30168         break;
30169       case BETWEEN:
30170         jj_consume_token(BETWEEN);
30171         break;
30172       case BY:
30173         jj_consume_token(BY);
30174         break;
30175       case CHAR:
30176         jj_consume_token(CHAR);
30177         break;
30178       case CHECK:
30179         jj_consume_token(CHECK);
30180         break;
30181       case CLUSTER:
30182         jj_consume_token(CLUSTER);
30183         break;
30184       case COMPRESS:
30185         jj_consume_token(COMPRESS);
30186         break;
30187       case CONNECT:
30188         jj_consume_token(CONNECT);
30189         break;
30190       case CREATE:
30191         jj_consume_token(CREATE);
30192         break;
30193       case DATE:
30194         jj_consume_token(DATE);
30195         break;
30196       case DECIMAL:
30197         jj_consume_token(DECIMAL);
30198         break;
30199       case _DEFAULT:
30200         jj_consume_token(_DEFAULT);
30201         break;
30202       case DELETE:
30203         jj_consume_token(DELETE);
30204         break;
30205       case DESC:
30206         jj_consume_token(DESC);
30207         break;
30208       case DISTINCT:
30209         jj_consume_token(DISTINCT);
30210         break;
30211       case DROP:
30212         jj_consume_token(DROP);
30213         break;
30214       case ELSE:
30215         jj_consume_token(ELSE);
30216         break;
30217       case EXCLUSIVE:
30218         jj_consume_token(EXCLUSIVE);
30219         break;
30220       case EXISTS:
30221         jj_consume_token(EXISTS);
30222         break;
30223       case FLOAT:
30224         jj_consume_token(FLOAT);
30225         break;
30226       case FOR:
30227         jj_consume_token(FOR);
30228         break;
30229       case FROM:
30230         jj_consume_token(FROM);
30231         break;
30232       case GRANT:
30233         jj_consume_token(GRANT);
30234         break;
30235       case GROUP:
30236         jj_consume_token(GROUP);
30237         break;
30238       case HAVING:
30239         jj_consume_token(HAVING);
30240         break;
30241       case IDENTIFIED:
30242         jj_consume_token(IDENTIFIED);
30243         break;
30244       case IN:
30245         jj_consume_token(IN);
30246         break;
30247       case INDEX:
30248         jj_consume_token(INDEX);
30249         break;
30250       case INSERT:
30251         jj_consume_token(INSERT);
30252         break;
30253       case INTEGER:
30254         jj_consume_token(INTEGER);
30255         break;
30256       case INTERSECT:
30257         jj_consume_token(INTERSECT);
30258         break;
30259       case INTO:
30260         jj_consume_token(INTO);
30261         break;
30262       case IS:
30263         jj_consume_token(IS);
30264         break;
30265       case LIKE:
30266         jj_consume_token(LIKE);
30267         break;
30268       case LOCK:
30269         jj_consume_token(LOCK);
30270         break;
30271       case LONG:
30272         jj_consume_token(LONG);
30273         break;
30274       case MINUS:
30275         jj_consume_token(MINUS);
30276         break;
30277       case MODE:
30278         jj_consume_token(MODE);
30279         break;
30280       case NOCOMPRESS:
30281         jj_consume_token(NOCOMPRESS);
30282         break;
30283       case NOT:
30284         jj_consume_token(NOT);
30285         break;
30286       case NOWAIT:
30287         jj_consume_token(NOWAIT);
30288         break;
30289       case NULL:
30290         jj_consume_token(NULL);
30291         break;
30292       case NUMBER:
30293         jj_consume_token(NUMBER);
30294         break;
30295       case OF:
30296         jj_consume_token(OF);
30297         break;
30298       case ON:
30299         jj_consume_token(ON);
30300         break;
30301       case OPTION:
30302         jj_consume_token(OPTION);
30303         break;
30304       case OR:
30305         jj_consume_token(OR);
30306         break;
30307       case ORDER:
30308         jj_consume_token(ORDER);
30309         break;
30310       case PCTFREE:
30311         jj_consume_token(PCTFREE);
30312         break;
30313       case PRIOR:
30314         jj_consume_token(PRIOR);
30315         break;
30316       case PUBLIC:
30317         jj_consume_token(PUBLIC);
30318         break;
30319       case RAW:
30320         jj_consume_token(RAW);
30321         break;
30322       case RESOURCE:
30323         jj_consume_token(RESOURCE);
30324         break;
30325       case REVOKE:
30326         jj_consume_token(REVOKE);
30327         break;
30328       case SELECT:
30329         jj_consume_token(SELECT);
30330         break;
30331       case SET:
30332         jj_consume_token(SET);
30333         break;
30334       case SHARE:
30335         jj_consume_token(SHARE);
30336         break;
30337       case SIZE:
30338         jj_consume_token(SIZE);
30339         break;
30340       case SMALLINT:
30341         jj_consume_token(SMALLINT);
30342         break;
30343       case START:
30344         jj_consume_token(START);
30345         break;
30346       case SYNONYM:
30347         jj_consume_token(SYNONYM);
30348         break;
30349       case TABLE:
30350         jj_consume_token(TABLE);
30351         break;
30352       case THEN:
30353         jj_consume_token(THEN);
30354         break;
30355       case TO:
30356         jj_consume_token(TO);
30357         break;
30358       case TRIGGER:
30359         jj_consume_token(TRIGGER);
30360         break;
30361       case UNION:
30362         jj_consume_token(UNION);
30363         break;
30364       case UNIQUE:
30365         jj_consume_token(UNIQUE);
30366         break;
30367       case UPDATE:
30368         jj_consume_token(UPDATE);
30369         break;
30370       case VALUES:
30371         jj_consume_token(VALUES);
30372         break;
30373       case VARCHAR:
30374         jj_consume_token(VARCHAR);
30375         break;
30376       case VARCHAR2:
30377         jj_consume_token(VARCHAR2);
30378         break;
30379       case VIEW:
30380         jj_consume_token(VIEW);
30381         break;
30382       case WHERE:
30383         jj_consume_token(WHERE);
30384         break;
30385       case WITH:
30386         jj_consume_token(WITH);
30387         break;
30388       default:
30389         jj_la1[453] = jj_gen;
30390         jj_consume_token(-1);
30391         throw new ParseException();
30392       }
30393    jjtree.closeNodeScope(jjtn000, true);
30394    jjtc000 = false;
30395    jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30396     } finally {
30397   if (jjtc000) {
30398     jjtree.closeNodeScope(jjtn000, true);
30399   }
30400     }
30401     throw new Error("Missing return statement in function");
30402   }
30403 
30404   final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30405                                               /*@bgen(jjtree) KEYWORD_UNRESERVED */
30406   ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30407   boolean jjtc000 = true;
30408   jjtree.openNodeScope(jjtn000);
30409     try {
30410       switch (jj_nt.kind) {
30411       case FALSE:
30412         jj_consume_token(FALSE);
30413         break;
30414       case TRUE:
30415         jj_consume_token(TRUE);
30416         break;
30417       case A:
30418         jj_consume_token(A);
30419         break;
30420       case ACCEPT:
30421         jj_consume_token(ACCEPT);
30422         break;
30423       case ADD:
30424         jj_consume_token(ADD);
30425         break;
30426       case AFTER:
30427         jj_consume_token(AFTER);
30428         break;
30429       case AGGREGATE:
30430         jj_consume_token(AGGREGATE);
30431         break;
30432       case ANALYZE:
30433         jj_consume_token(ANALYZE);
30434         break;
30435       case ASSOCIATE:
30436         jj_consume_token(ASSOCIATE);
30437         break;
30438       case AT:
30439         jj_consume_token(AT);
30440         break;
30441       case ATTACH:
30442         jj_consume_token(ATTACH);
30443         break;
30444       case ATTRIBUTE:
30445         jj_consume_token(ATTRIBUTE);
30446         break;
30447       case AUDIT:
30448         jj_consume_token(AUDIT);
30449         break;
30450       case AUTHENTICATED:
30451         jj_consume_token(AUTHENTICATED);
30452         break;
30453       case AUTHID:
30454         jj_consume_token(AUTHID);
30455         break;
30456       case BEFORE:
30457         jj_consume_token(BEFORE);
30458         break;
30459       case BFILE:
30460         jj_consume_token(BFILE);
30461         break;
30462       case BLOB:
30463         jj_consume_token(BLOB);
30464         break;
30465       case BOTH:
30466         jj_consume_token(BOTH);
30467         break;
30468       case BULK:
30469         jj_consume_token(BULK);
30470         break;
30471       case BYTE:
30472         jj_consume_token(BYTE);
30473         break;
30474       case CALL:
30475         jj_consume_token(CALL);
30476         break;
30477       case CASCADE:
30478         jj_consume_token(CASCADE);
30479         break;
30480       case CAST:
30481         jj_consume_token(CAST);
30482         break;
30483       case CHAR_CS:
30484         jj_consume_token(CHAR_CS);
30485         break;
30486       case CHARACTER:
30487         jj_consume_token(CHARACTER);
30488         break;
30489       case CHARSETFORM:
30490         jj_consume_token(CHARSETFORM);
30491         break;
30492       case CHARSETID:
30493         jj_consume_token(CHARSETID);
30494         break;
30495       case CLOB:
30496         jj_consume_token(CLOB);
30497         break;
30498       case CLOSE:
30499         jj_consume_token(CLOSE);
30500         break;
30501       case COALESCE:
30502         jj_consume_token(COALESCE);
30503         break;
30504       case COLLECT:
30505         jj_consume_token(COLLECT);
30506         break;
30507       case COLUMN:
30508         jj_consume_token(COLUMN);
30509         break;
30510       case COMMENT:
30511         jj_consume_token(COMMENT);
30512         break;
30513       case COMMIT:
30514         jj_consume_token(COMMIT);
30515         break;
30516       case COMPOUND:
30517         jj_consume_token(COMPOUND);
30518         break;
30519       case CONSTRUCTOR:
30520         jj_consume_token(CONSTRUCTOR);
30521         break;
30522       case CONTEXT:
30523         jj_consume_token(CONTEXT);
30524         break;
30525       case CONTINUE:
30526         jj_consume_token(CONTINUE);
30527         break;
30528       case CONVERT:
30529         jj_consume_token(CONVERT);
30530         break;
30531       case COPY:
30532         jj_consume_token(COPY);
30533         break;
30534       case CURRENT:
30535         jj_consume_token(CURRENT);
30536         break;
30537       case CURRENT_USER:
30538         jj_consume_token(CURRENT_USER);
30539         break;
30540       case CURSOR:
30541         jj_consume_token(CURSOR);
30542         break;
30543       case DATA:
30544         jj_consume_token(DATA);
30545         break;
30546       case DATABASE:
30547         jj_consume_token(DATABASE);
30548         break;
30549       case DAY:
30550         jj_consume_token(DAY);
30551         break;
30552       case DBTIMEZONE:
30553         jj_consume_token(DBTIMEZONE);
30554         break;
30555       case DDL:
30556         jj_consume_token(DDL);
30557         break;
30558       case DEC:
30559         jj_consume_token(DEC);
30560         break;
30561       case DEFINE:
30562         jj_consume_token(DEFINE);
30563         break;
30564       case DEFINER:
30565         jj_consume_token(DEFINER);
30566         break;
30567       case DIRECTORY:
30568         jj_consume_token(DIRECTORY);
30569         break;
30570       case DISABLE:
30571         jj_consume_token(DISABLE);
30572         break;
30573       case DISASSOCIATE:
30574         jj_consume_token(DISASSOCIATE);
30575         break;
30576       case DISCONNECT:
30577         jj_consume_token(DISCONNECT);
30578         break;
30579       case DOUBLE:
30580         jj_consume_token(DOUBLE);
30581         break;
30582       case EACH:
30583         jj_consume_token(EACH);
30584         break;
30585       case ELEMENT:
30586         jj_consume_token(ELEMENT);
30587         break;
30588       case EMPTY:
30589         jj_consume_token(EMPTY);
30590         break;
30591       case ENABLE:
30592         jj_consume_token(ENABLE);
30593         break;
30594       case ESCAPE:
30595         jj_consume_token(ESCAPE);
30596         break;
30597       case EXCEPT:
30598         jj_consume_token(EXCEPT);
30599         break;
30600       case EXCEPTIONS:
30601         jj_consume_token(EXCEPTIONS);
30602         break;
30603       case EXIT:
30604         jj_consume_token(EXIT);
30605         break;
30606       case EXTENDS:
30607         jj_consume_token(EXTENDS);
30608         break;
30609       case EXTERNAL:
30610         jj_consume_token(EXTERNAL);
30611         break;
30612       case EXTRACT:
30613         jj_consume_token(EXTRACT);
30614         break;
30615       case FINAL:
30616         jj_consume_token(FINAL);
30617         break;
30618       case FOLLOWS:
30619         jj_consume_token(FOLLOWS);
30620         break;
30621       case FORCE:
30622         jj_consume_token(FORCE);
30623         break;
30624       case FUNCTION:
30625         jj_consume_token(FUNCTION);
30626         break;
30627       case GLOBAL:
30628         jj_consume_token(GLOBAL);
30629         break;
30630       case HASH:
30631         jj_consume_token(HASH);
30632         break;
30633       case HEAP:
30634         jj_consume_token(HEAP);
30635         break;
30636       case HOST:
30637         jj_consume_token(HOST);
30638         break;
30639       case HOUR:
30640         jj_consume_token(HOUR);
30641         break;
30642       case IMMEDIATE:
30643         jj_consume_token(IMMEDIATE);
30644         break;
30645       case INDEXTYPE:
30646         jj_consume_token(INDEXTYPE);
30647         break;
30648       case INDICATOR:
30649         jj_consume_token(INDICATOR);
30650         break;
30651       case INDICES:
30652         jj_consume_token(INDICES);
30653         break;
30654       case INSTANTIABLE:
30655         jj_consume_token(INSTANTIABLE);
30656         break;
30657       case INTERVAL:
30658         jj_consume_token(INTERVAL);
30659         break;
30660       case INVALIDATE:
30661         jj_consume_token(INVALIDATE);
30662         break;
30663       case ISOLATION:
30664         jj_consume_token(ISOLATION);
30665         break;
30666       case JAVA:
30667         jj_consume_token(JAVA);
30668         break;
30669       case LANGUAGE:
30670         jj_consume_token(LANGUAGE);
30671         break;
30672       case LEADING:
30673         jj_consume_token(LEADING);
30674         break;
30675       case LEFT:
30676         jj_consume_token(LEFT);
30677         break;
30678       case LENGTH:
30679         jj_consume_token(LENGTH);
30680         break;
30681       case LEVEL:
30682         jj_consume_token(LEVEL);
30683         break;
30684       case LIBRARY:
30685         jj_consume_token(LIBRARY);
30686         break;
30687       case LIMIT:
30688         jj_consume_token(LIMIT);
30689         break;
30690       case LINK:
30691         jj_consume_token(LINK);
30692         break;
30693       case LOCAL:
30694         jj_consume_token(LOCAL);
30695         break;
30696       case LOGOFF:
30697         jj_consume_token(LOGOFF);
30698         break;
30699       case LOGON:
30700         jj_consume_token(LOGON);
30701         break;
30702       case MAP:
30703         jj_consume_token(MAP);
30704         break;
30705       case MAX:
30706         jj_consume_token(MAX);
30707         break;
30708       case MAXLEN:
30709         jj_consume_token(MAXLEN);
30710         break;
30711       case MEMBER:
30712         jj_consume_token(MEMBER);
30713         break;
30714       case MERGE:
30715         jj_consume_token(MERGE);
30716         break;
30717       case MIN:
30718         jj_consume_token(MIN);
30719         break;
30720       case MINUTE:
30721         jj_consume_token(MINUTE);
30722         break;
30723       case MLSLABEL:
30724         jj_consume_token(MLSLABEL);
30725         break;
30726       case MODIFY:
30727         jj_consume_token(MODIFY);
30728         break;
30729       case MONTH:
30730         jj_consume_token(MONTH);
30731         break;
30732       case MULTISET:
30733         jj_consume_token(MULTISET);
30734         break;
30735       case NAME:
30736         jj_consume_token(NAME);
30737         break;
30738       case NATURAL:
30739         jj_consume_token(NATURAL);
30740         break;
30741       case NCHAR:
30742         jj_consume_token(NCHAR);
30743         break;
30744       case NCHAR_CS:
30745         jj_consume_token(NCHAR_CS);
30746         break;
30747       case NCLOB:
30748         jj_consume_token(NCLOB);
30749         break;
30750       case NESTED:
30751         jj_consume_token(NESTED);
30752         break;
30753       case NEW:
30754         jj_consume_token(NEW);
30755         break;
30756       case NO:
30757         jj_consume_token(NO);
30758         break;
30759       case NOAUDIT:
30760         jj_consume_token(NOAUDIT);
30761         break;
30762       case NUMERIC:
30763         jj_consume_token(NUMERIC);
30764         break;
30765       case NVARCHAR2:
30766         jj_consume_token(NVARCHAR2);
30767         break;
30768       case OBJECT:
30769         jj_consume_token(OBJECT);
30770         break;
30771       case OID:
30772         jj_consume_token(OID);
30773         break;
30774       case OLD:
30775         jj_consume_token(OLD);
30776         break;
30777       case OPAQUE:
30778         jj_consume_token(OPAQUE);
30779         break;
30780       case OPEN:
30781         jj_consume_token(OPEN);
30782         break;
30783       case ORGANIZATION:
30784         jj_consume_token(ORGANIZATION);
30785         break;
30786       case OTHERS:
30787         jj_consume_token(OTHERS);
30788         break;
30789       case OVERRIDING:
30790         jj_consume_token(OVERRIDING);
30791         break;
30792       case PACKAGE:
30793         jj_consume_token(PACKAGE);
30794         break;
30795       case PARAMETERS:
30796         jj_consume_token(PARAMETERS);
30797         break;
30798       case PARENT:
30799         jj_consume_token(PARENT);
30800         break;
30801       case PARTITION:
30802         jj_consume_token(PARTITION);
30803         break;
30804       case PRECISION:
30805         jj_consume_token(PRECISION);
30806         break;
30807       case PRESERVE:
30808         jj_consume_token(PRESERVE);
30809         break;
30810       case PRINT:
30811         jj_consume_token(PRINT);
30812         break;
30813       case PROCEDURE:
30814         jj_consume_token(PROCEDURE);
30815         break;
30816       case QUIT:
30817         jj_consume_token(QUIT);
30818         break;
30819       case RANGE:
30820         jj_consume_token(RANGE);
30821         break;
30822       case REAL:
30823         jj_consume_token(REAL);
30824         break;
30825       case RECORD:
30826         jj_consume_token(RECORD);
30827         break;
30828       case REF:
30829         jj_consume_token(REF);
30830         break;
30831       case RELIES_ON:
30832         jj_consume_token(RELIES_ON);
30833         break;
30834       case REMARK:
30835         jj_consume_token(REMARK);
30836         break;
30837       case RESULT:
30838         jj_consume_token(RESULT);
30839         break;
30840       case RETURN:
30841         jj_consume_token(RETURN);
30842         break;
30843       case RETURNING:
30844         jj_consume_token(RETURNING);
30845         break;
30846       case REVERSE:
30847         jj_consume_token(REVERSE);
30848         break;
30849       case RIGHT:
30850         jj_consume_token(RIGHT);
30851         break;
30852       case ROLLBACK:
30853         jj_consume_token(ROLLBACK);
30854         break;
30855       case ROW:
30856         jj_consume_token(ROW);
30857         break;
30858       case ROWID:
30859         jj_consume_token(ROWID);
30860         break;
30861       case ROWNUM:
30862         jj_consume_token(ROWNUM);
30863         break;
30864       case ROWS:
30865         jj_consume_token(ROWS);
30866         break;
30867       case SAVE:
30868         jj_consume_token(SAVE);
30869         break;
30870       case SAVEPOINT:
30871         jj_consume_token(SAVEPOINT);
30872         break;
30873       case SCHEMA:
30874         jj_consume_token(SCHEMA);
30875         break;
30876       case SECOND:
30877         jj_consume_token(SECOND);
30878         break;
30879       case SELF:
30880         jj_consume_token(SELF);
30881         break;
30882       case SERVERERROR:
30883         jj_consume_token(SERVERERROR);
30884         break;
30885       case SESSIONTIMEZONE:
30886         jj_consume_token(SESSIONTIMEZONE);
30887         break;
30888       case SET:
30889         jj_consume_token(SET);
30890         break;
30891       case SHARED:
30892         jj_consume_token(SHARED);
30893         break;
30894       case SHUTDOWN:
30895         jj_consume_token(SHUTDOWN);
30896         break;
30897       case SPACE:
30898         jj_consume_token(SPACE);
30899         break;
30900       case STARTUP:
30901         jj_consume_token(STARTUP);
30902         break;
30903       case STATEMENT:
30904         jj_consume_token(STATEMENT);
30905         break;
30906       case STATIC:
30907         jj_consume_token(STATIC);
30908         break;
30909       case STATISTICS:
30910         jj_consume_token(STATISTICS);
30911         break;
30912       case STRUCT:
30913         jj_consume_token(STRUCT);
30914         break;
30915       case SUBMULTISET:
30916         jj_consume_token(SUBMULTISET);
30917         break;
30918       case SUBSTITUTABLE:
30919         jj_consume_token(SUBSTITUTABLE);
30920         break;
30921       case SUBTYPE:
30922         jj_consume_token(SUBTYPE);
30923         break;
30924       case SUCCESSFUL:
30925         jj_consume_token(SUCCESSFUL);
30926         break;
30927       case SUSPEND:
30928         jj_consume_token(SUSPEND);
30929         break;
30930       case TDO:
30931         jj_consume_token(TDO);
30932         break;
30933       case TEMPORARY:
30934         jj_consume_token(TEMPORARY);
30935         break;
30936       case TIME:
30937         jj_consume_token(TIME);
30938         break;
30939       case TIMESTAMP:
30940         jj_consume_token(TIMESTAMP);
30941         break;
30942       case TIMEZONE_ABBR:
30943         jj_consume_token(TIMEZONE_ABBR);
30944         break;
30945       case TIMEZONE_HOUR:
30946         jj_consume_token(TIMEZONE_HOUR);
30947         break;
30948       case TIMEZONE_MINUTE:
30949         jj_consume_token(TIMEZONE_MINUTE);
30950         break;
30951       case TIMEZONE_REGION:
30952         jj_consume_token(TIMEZONE_REGION);
30953         break;
30954       case TRAILING:
30955         jj_consume_token(TRAILING);
30956         break;
30957       case TRANSACTION:
30958         jj_consume_token(TRANSACTION);
30959         break;
30960       case TREAT:
30961         jj_consume_token(TREAT);
30962         break;
30963       case TRIM:
30964         jj_consume_token(TRIM);
30965         break;
30966       case TRUNCATE:
30967         jj_consume_token(TRUNCATE);
30968         break;
30969       case UNDEFINE:
30970         jj_consume_token(UNDEFINE);
30971         break;
30972       case UNDER:
30973         jj_consume_token(UNDER);
30974         break;
30975       case UROWID:
30976         jj_consume_token(UROWID);
30977         break;
30978       case USER:
30979         jj_consume_token(USER);
30980         break;
30981       case USING:
30982         jj_consume_token(USING);
30983         break;
30984       case VARRAY:
30985         jj_consume_token(VARRAY);
30986         break;
30987       case VARIABLE:
30988         jj_consume_token(VARIABLE);
30989         break;
30990       case VARYING:
30991         jj_consume_token(VARYING);
30992         break;
30993       case WHENEVER:
30994         jj_consume_token(WHENEVER);
30995         break;
30996       case YEAR:
30997         jj_consume_token(YEAR);
30998         break;
30999       case YES:
31000         jj_consume_token(YES);
31001         break;
31002       case ZONE:
31003         jj_consume_token(ZONE);
31004         break;
31005       case SHOW:
31006         jj_consume_token(SHOW);
31007         break;
31008       case WRAPPED:
31009         jj_consume_token(WRAPPED);
31010         break;
31011       case SYS_REFCURSOR:
31012         jj_consume_token(SYS_REFCURSOR);
31013         break;
31014       case EDITIONABLE:
31015         jj_consume_token(EDITIONABLE);
31016         break;
31017       case NONEDITIONABLE:
31018         jj_consume_token(NONEDITIONABLE);
31019         break;
31020       case ACCESSIBLE:
31021         jj_consume_token(ACCESSIBLE);
31022         break;
31023       case NULLIF:
31024         jj_consume_token(NULLIF);
31025         break;
31026       case RENAME:
31027         jj_consume_token(RENAME);
31028         break;
31029       case RELEASE:
31030         jj_consume_token(RELEASE);
31031         break;
31032       case INLINE:
31033         jj_consume_token(INLINE);
31034         break;
31035       default:
31036         jj_la1[454] = jj_gen;
31037         jj_consume_token(-1);
31038         throw new ParseException();
31039       }
31040   jjtree.closeNodeScope(jjtn000, true);
31041   jjtc000 = false;
31042   jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31043     } finally {
31044   if (jjtc000) {
31045     jjtree.closeNodeScope(jjtn000, true);
31046   }
31047     }
31048     throw new Error("Missing return statement in function");
31049   }
31050 
31051 //SRT 2011-04-17 - END  */
31052 /**
31053  * 2006-05-20 - Matthias Hendler - added <OLD> and <PARENT>  
31054  */
31055   final public ASTID ID() throws ParseException {
31056              /*@bgen(jjtree) ID */
31057   ASTID jjtn000 = new ASTID(this, JJTID);
31058   boolean jjtc000 = true;
31059   jjtree.openNodeScope(jjtn000);
31060     try {
31061       switch (jj_nt.kind) {
31062       case IDENTIFIER:
31063         jj_consume_token(IDENTIFIER);
31064         break;
31065       case QUOTED_LITERAL:
31066         jj_consume_token(QUOTED_LITERAL);
31067         break;
31068       case DEFINER:
31069       case CURRENT_USER:
31070       case LANGUAGE:
31071       case INLINE:
31072       case ADD:
31073       case AGGREGATE:
31074       case AT:
31075       case ATTRIBUTE:
31076       case AUTHID:
31077       case BULK:
31078       case BYTE:
31079       case CASCADE:
31080       case CLOSE:
31081       case COALESCE:
31082       case COLLECT:
31083       case COLUMN:
31084       case COMMENT:
31085       case COMMIT:
31086       case CONSTRUCTOR:
31087       case CONTINUE:
31088       case CONVERT:
31089       case CURRENT:
31090       case CURSOR:
31091       case DATA:
31092       case DAY:
31093       case DISABLE:
31094       case EDITIONABLE:
31095       case ELEMENT:
31096       case ENABLE:
31097       case ESCAPE:
31098       case EXCEPT:
31099       case EXCEPTIONS:
31100       case EXIT:
31101       case EXTERNAL:
31102       case EXTENDS:
31103       case EXTRACT:
31104       case FALSE:
31105       case FINAL:
31106       case FORCE:
31107       case FUNCTION:
31108       case GLOBAL:
31109       case HASH:
31110       case HEAP:
31111       case HOUR:
31112       case IMMEDIATE:
31113       case INDICES:
31114       case INDEXTYPE:
31115       case INDICATOR:
31116       case INSTANTIABLE:
31117       case INTERVAL:
31118       case INVALIDATE:
31119       case ISOLATION:
31120       case JAVA:
31121       case LEVEL:
31122       case LIMIT:
31123       case MAP:
31124       case MAX:
31125       case MEMBER:
31126       case MERGE:
31127       case MIN:
31128       case MINUTE:
31129       case MLSLABEL:
31130       case MODIFY:
31131       case MONTH:
31132       case NATURAL:
31133       case NEW:
31134       case NO:
31135       case NONEDITIONABLE:
31136       case NULLIF:
31137       case OBJECT:
31138       case OID:
31139       case OPAQUE:
31140       case OPEN:
31141       case ORGANIZATION:
31142       case OTHERS:
31143       case OVERRIDING:
31144       case PACKAGE:
31145       case PARTITION:
31146       case PRESERVE:
31147       case PROCEDURE:
31148       case RANGE:
31149       case REAL:
31150       case RECORD:
31151       case REF:
31152       case RELEASE:
31153       case RELIES_ON:
31154       case RENAME:
31155       case RESULT:
31156       case RETURN:
31157       case RETURNING:
31158       case REVERSE:
31159       case ROLLBACK:
31160       case ROW:
31161       case ROWS:
31162       case ROWID:
31163       case ROWNUM:
31164       case SAVE:
31165       case SAVEPOINT:
31166       case SECOND:
31167       case SELF:
31168       case SET:
31169       case SPACE:
31170       case STATIC:
31171       case SUBTYPE:
31172       case SUBSTITUTABLE:
31173       case SUCCESSFUL:
31174       case SYS_REFCURSOR:
31175       case TEMPORARY:
31176       case TIME:
31177       case TIMESTAMP:
31178       case TIMEZONE_REGION:
31179       case TIMEZONE_ABBR:
31180       case TIMEZONE_MINUTE:
31181       case TIMEZONE_HOUR:
31182       case TRANSACTION:
31183       case TRUE:
31184       case UNDER:
31185       case USING:
31186       case YES:
31187       case SHOW:
31188       case A:
31189       case DOUBLE:
31190       case DEC:
31191       case PRECISION:
31192       case NUMERIC:
31193       case NCHAR:
31194       case NVARCHAR2:
31195       case UROWID:
31196       case VARRAY:
31197       case VARYING:
31198       case BFILE:
31199       case BLOB:
31200       case CLOB:
31201       case NCLOB:
31202       case YEAR:
31203       case LOCAL:
31204       case ZONE:
31205       case CHARACTER:
31206       case AFTER:
31207       case BEFORE:
31208       case OLD:
31209       case PARENT:
31210       case ANALYZE:
31211       case ASSOCIATE:
31212       case AUDIT:
31213       case COMPOUND:
31214       case DATABASE:
31215       case CALL:
31216       case DDL:
31217       case DISASSOCIATE:
31218       case EACH:
31219       case FOLLOWS:
31220       case LOGOFF:
31221       case LOGON:
31222       case NESTED:
31223       case NOAUDIT:
31224       case SCHEMA:
31225       case SERVERERROR:
31226       case SHUTDOWN:
31227       case STARTUP:
31228       case STATEMENT:
31229       case STATISTICS:
31230       case SUSPEND:
31231       case TRUNCATE:
31232       case WRAPPED:
31233       case LIBRARY:
31234       case NAME:
31235       case STRUCT:
31236       case CONTEXT:
31237       case PARAMETERS:
31238       case LENGTH:
31239       case TDO:
31240       case MAXLEN:
31241       case CHARSETID:
31242       case CHARSETFORM:
31243       case ACCEPT:
31244       case ACCESSIBLE:
31245       case COPY:
31246       case DEFINE:
31247       case DISCONNECT:
31248       case HOST:
31249       case PRINT:
31250       case QUIT:
31251       case REMARK:
31252       case UNDEFINE:
31253       case VARIABLE:
31254       case WHENEVER:
31255       case ATTACH:
31256       case CAST:
31257       case TREAT:
31258       case TRIM:
31259       case LEFT:
31260       case RIGHT:
31261       case BOTH:
31262       case EMPTY:
31263       case MULTISET:
31264       case SUBMULTISET:
31265       case LEADING:
31266       case TRAILING:
31267       case CHAR_CS:
31268       case NCHAR_CS:
31269       case DBTIMEZONE:
31270       case SESSIONTIMEZONE:
31271       case AUTHENTICATED:
31272       case LINK:
31273       case SHARED:
31274       case DIRECTORY:
31275       case USER:
31276         KEYWORD_UNRESERVED();
31277         break;
31278       case REPLACE:
31279         jj_consume_token(REPLACE);
31280         break;
31281       case SERIALLY_REUSABLE:
31282         jj_consume_token(SERIALLY_REUSABLE);
31283         break;
31284       case RESTRICT_REFERENCES:
31285         jj_consume_token(RESTRICT_REFERENCES);
31286         break;
31287       case EXCEPTION_INIT:
31288         jj_consume_token(EXCEPTION_INIT);
31289         break;
31290       case AUTONOMOUS_TRANSACTION:
31291         jj_consume_token(AUTONOMOUS_TRANSACTION);
31292         break;
31293       case ALL:
31294         jj_consume_token(ALL);
31295         break;
31296       case ALTER:
31297         jj_consume_token(ALTER);
31298         break;
31299       case AND:
31300         jj_consume_token(AND);
31301         break;
31302       case ANY:
31303         jj_consume_token(ANY);
31304         break;
31305       case ARRAY:
31306         jj_consume_token(ARRAY);
31307         break;
31308       case AS:
31309         jj_consume_token(AS);
31310         break;
31311       case ASC:
31312         jj_consume_token(ASC);
31313         break;
31314       case AVG:
31315         jj_consume_token(AVG);
31316         break;
31317       case BETWEEN:
31318         jj_consume_token(BETWEEN);
31319         break;
31320       case BINARY_INTEGER:
31321         jj_consume_token(BINARY_INTEGER);
31322         break;
31323       case BODY:
31324         jj_consume_token(BODY);
31325         break;
31326       case BOOLEAN:
31327         jj_consume_token(BOOLEAN);
31328         break;
31329       case BY:
31330         jj_consume_token(BY);
31331         break;
31332       case CASE:
31333         jj_consume_token(CASE);
31334         break;
31335       case CHAR:
31336         jj_consume_token(CHAR);
31337         break;
31338       case CHAR_BASE:
31339         jj_consume_token(CHAR_BASE);
31340         break;
31341       case CHECK:
31342         jj_consume_token(CHECK);
31343         break;
31344       case CLUSTER:
31345         jj_consume_token(CLUSTER);
31346         break;
31347       case COMPRESS:
31348         jj_consume_token(COMPRESS);
31349         break;
31350       case CONNECT:
31351         jj_consume_token(CONNECT);
31352         break;
31353       case CONSTANT:
31354         jj_consume_token(CONSTANT);
31355         break;
31356       case CREATE:
31357         jj_consume_token(CREATE);
31358         break;
31359       case CURRVAL:
31360         jj_consume_token(CURRVAL);
31361         break;
31362       case DATE:
31363         jj_consume_token(DATE);
31364         break;
31365       case DECLARE:
31366         jj_consume_token(DECLARE);
31367         break;
31368       case DECIMAL:
31369         jj_consume_token(DECIMAL);
31370         break;
31371       case _DEFAULT:
31372         jj_consume_token(_DEFAULT);
31373         break;
31374       case DELETE:
31375         jj_consume_token(DELETE);
31376         break;
31377       case DESC:
31378         jj_consume_token(DESC);
31379         break;
31380       case DISTINCT:
31381         jj_consume_token(DISTINCT);
31382         break;
31383       case DO:
31384         jj_consume_token(DO);
31385         break;
31386       case DROP:
31387         jj_consume_token(DROP);
31388         break;
31389       case ELSE:
31390         jj_consume_token(ELSE);
31391         break;
31392       case ELSIF:
31393         jj_consume_token(ELSIF);
31394         break;
31395       case EXCEPTION:
31396         jj_consume_token(EXCEPTION);
31397         break;
31398       case EXCLUSIVE:
31399         jj_consume_token(EXCLUSIVE);
31400         break;
31401       case EXECUTE:
31402         jj_consume_token(EXECUTE);
31403         break;
31404       case EXISTS:
31405         jj_consume_token(EXISTS);
31406         break;
31407       case FETCH:
31408         jj_consume_token(FETCH);
31409         break;
31410       case FLOAT:
31411         jj_consume_token(FLOAT);
31412         break;
31413       case FOR:
31414         jj_consume_token(FOR);
31415         break;
31416       case FORALL:
31417         jj_consume_token(FORALL);
31418         break;
31419       case FROM:
31420         jj_consume_token(FROM);
31421         break;
31422       case GOTO:
31423         jj_consume_token(GOTO);
31424         break;
31425       case GROUP:
31426         jj_consume_token(GROUP);
31427         break;
31428       case HAVING:
31429         jj_consume_token(HAVING);
31430         break;
31431       case IF:
31432         jj_consume_token(IF);
31433         break;
31434       case IN:
31435         jj_consume_token(IN);
31436         break;
31437       case INDEX:
31438         jj_consume_token(INDEX);
31439         break;
31440       case INSERT:
31441         jj_consume_token(INSERT);
31442         break;
31443       case INTEGER:
31444         jj_consume_token(INTEGER);
31445         break;
31446       case INTERFACE:
31447         jj_consume_token(INTERFACE);
31448         break;
31449       case INTERSECT:
31450         jj_consume_token(INTERSECT);
31451         break;
31452       case INTO:
31453         jj_consume_token(INTO);
31454         break;
31455       case IS:
31456         jj_consume_token(IS);
31457         break;
31458       case LIKE:
31459         jj_consume_token(LIKE);
31460         break;
31461       case LIMITED:
31462         jj_consume_token(LIMITED);
31463         break;
31464       case LOCK:
31465         jj_consume_token(LOCK);
31466         break;
31467       case LONG:
31468         jj_consume_token(LONG);
31469         break;
31470       case LOOP:
31471         jj_consume_token(LOOP);
31472         break;
31473       case MINUS:
31474         jj_consume_token(MINUS);
31475         break;
31476       case MOD:
31477         jj_consume_token(MOD);
31478         break;
31479       case MODE:
31480         jj_consume_token(MODE);
31481         break;
31482       case NATURALN:
31483         jj_consume_token(NATURALN);
31484         break;
31485       case NEXTVAL:
31486         jj_consume_token(NEXTVAL);
31487         break;
31488       case NOCOPY:
31489         jj_consume_token(NOCOPY);
31490         break;
31491       case NOT:
31492         jj_consume_token(NOT);
31493         break;
31494       case NOWAIT:
31495         jj_consume_token(NOWAIT);
31496         break;
31497       case NULL:
31498         jj_consume_token(NULL);
31499         break;
31500       case NUMBER:
31501         jj_consume_token(NUMBER);
31502         break;
31503       case NUMBER_BASE:
31504         jj_consume_token(NUMBER_BASE);
31505         break;
31506       case OCIROWID:
31507         jj_consume_token(OCIROWID);
31508         break;
31509       case OF:
31510         jj_consume_token(OF);
31511         break;
31512       case ON:
31513         jj_consume_token(ON);
31514         break;
31515       case BFILE_BASE:
31516         jj_consume_token(BFILE_BASE);
31517         break;
31518       case BLOB_BASE:
31519         jj_consume_token(BLOB_BASE);
31520         break;
31521       case CLOB_BASE:
31522         jj_consume_token(CLOB_BASE);
31523         break;
31524       case DATE_BASE:
31525         jj_consume_token(DATE_BASE);
31526         break;
31527       case OPERATOR:
31528         jj_consume_token(OPERATOR);
31529         break;
31530       case OPTION:
31531         jj_consume_token(OPTION);
31532         break;
31533       case OR:
31534         jj_consume_token(OR);
31535         break;
31536       case ORDER:
31537         jj_consume_token(ORDER);
31538         break;
31539       case OUT:
31540         jj_consume_token(OUT);
31541         break;
31542       case PCTFREE:
31543         jj_consume_token(PCTFREE);
31544         break;
31545       case PLS_INTEGER:
31546         jj_consume_token(PLS_INTEGER);
31547         break;
31548       case POSITIVE:
31549         jj_consume_token(POSITIVE);
31550         break;
31551       case POSITIVEN:
31552         jj_consume_token(POSITIVEN);
31553         break;
31554       case PRIOR:
31555         jj_consume_token(PRIOR);
31556         break;
31557       case PRIVATE:
31558         jj_consume_token(PRIVATE);
31559         break;
31560       case PROMPT:
31561         jj_consume_token(PROMPT);
31562         break;
31563       case PUBLIC:
31564         jj_consume_token(PUBLIC);
31565         break;
31566       case RAISE:
31567         jj_consume_token(RAISE);
31568         break;
31569       case RAW:
31570         jj_consume_token(RAW);
31571         break;
31572       case ROWTYPE:
31573         jj_consume_token(ROWTYPE);
31574         break;
31575       case SELECT:
31576         jj_consume_token(SELECT);
31577         break;
31578       case SEPARATE:
31579         jj_consume_token(SEPARATE);
31580         break;
31581       case SHARE:
31582         jj_consume_token(SHARE);
31583         break;
31584       case SMALLINT:
31585         jj_consume_token(SMALLINT);
31586         break;
31587       case SQL:
31588         jj_consume_token(SQL);
31589         break;
31590       case SQLCODE:
31591         jj_consume_token(SQLCODE);
31592         break;
31593       case SQLERRM:
31594         jj_consume_token(SQLERRM);
31595         break;
31596       case START:
31597         jj_consume_token(START);
31598         break;
31599       case STDDEV:
31600         jj_consume_token(STDDEV);
31601         break;
31602       case SUM:
31603         jj_consume_token(SUM);
31604         break;
31605       case SYNONYM:
31606         jj_consume_token(SYNONYM);
31607         break;
31608       case SYSDATE:
31609         jj_consume_token(SYSDATE);
31610         break;
31611       case TABLE:
31612         jj_consume_token(TABLE);
31613         break;
31614       case THEN:
31615         jj_consume_token(THEN);
31616         break;
31617       case TO:
31618         jj_consume_token(TO);
31619         break;
31620       case TRIGGER:
31621         jj_consume_token(TRIGGER);
31622         break;
31623       case TYPE:
31624         jj_consume_token(TYPE);
31625         break;
31626       case UI:
31627         jj_consume_token(UI);
31628         break;
31629       case UPDATE:
31630         jj_consume_token(UPDATE);
31631         break;
31632       case VARCHAR:
31633         jj_consume_token(VARCHAR);
31634         break;
31635       case VARCHAR2:
31636         jj_consume_token(VARCHAR2);
31637         break;
31638       case INT:
31639         jj_consume_token(INT);
31640         break;
31641       case SIGNTYPE:
31642         jj_consume_token(SIGNTYPE);
31643         break;
31644       case STRING:
31645         jj_consume_token(STRING);
31646         break;
31647       case WITH:
31648         jj_consume_token(WITH);
31649         break;
31650       case WHILE:
31651         jj_consume_token(WHILE);
31652         break;
31653       case JAVA_INTERFACE_CLASS:
31654         jj_consume_token(JAVA_INTERFACE_CLASS);
31655         break;
31656       case SQLDATA_CLASS:
31657         jj_consume_token(SQLDATA_CLASS);
31658         break;
31659       case CUSTOMDATUM_CLASS:
31660         jj_consume_token(CUSTOMDATUM_CLASS);
31661         break;
31662       case ORADATA_CLASS:
31663         jj_consume_token(ORADATA_CLASS);
31664         break;
31665       default:
31666         jj_la1[455] = jj_gen;
31667         jj_consume_token(-1);
31668         throw new ParseException();
31669       }
31670           jjtree.closeNodeScope(jjtn000, true);
31671           jjtc000 = false;
31672           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31673     } catch (Throwable jjte000) {
31674           if (jjtc000) {
31675             jjtree.clearNodeScope(jjtn000);
31676             jjtc000 = false;
31677           } else {
31678             jjtree.popNode();
31679           }
31680           if (jjte000 instanceof RuntimeException) {
31681             {if (true) throw (RuntimeException)jjte000;}
31682           }
31683           if (jjte000 instanceof ParseException) {
31684             {if (true) throw (ParseException)jjte000;}
31685           }
31686           {if (true) throw (Error)jjte000;}
31687     } finally {
31688           if (jjtc000) {
31689             jjtree.closeNodeScope(jjtn000, true);
31690           }
31691     }
31692     throw new Error("Missing return statement in function");
31693   }
31694 
31695 /**
31696  * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
31697  */
31698   final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31699                                    /*@bgen(jjtree) UnqualifiedID */
31700   ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31701   boolean jjtc000 = true;
31702   jjtree.openNodeScope(jjtn000);
31703     try {
31704       switch (jj_nt.kind) {
31705       case IDENTIFIER:
31706         jj_consume_token(IDENTIFIER);
31707         break;
31708       case QUOTED_LITERAL:
31709         jj_consume_token(QUOTED_LITERAL);
31710         break;
31711       case DEFINER:
31712       case CURRENT_USER:
31713       case LANGUAGE:
31714       case INLINE:
31715       case ADD:
31716       case AGGREGATE:
31717       case AT:
31718       case ATTRIBUTE:
31719       case AUTHID:
31720       case BULK:
31721       case BYTE:
31722       case CASCADE:
31723       case CLOSE:
31724       case COALESCE:
31725       case COLLECT:
31726       case COLUMN:
31727       case COMMENT:
31728       case COMMIT:
31729       case CONSTRUCTOR:
31730       case CONTINUE:
31731       case CONVERT:
31732       case CURRENT:
31733       case CURSOR:
31734       case DATA:
31735       case DAY:
31736       case DISABLE:
31737       case EDITIONABLE:
31738       case ELEMENT:
31739       case ENABLE:
31740       case ESCAPE:
31741       case EXCEPT:
31742       case EXCEPTIONS:
31743       case EXIT:
31744       case EXTERNAL:
31745       case EXTENDS:
31746       case EXTRACT:
31747       case FALSE:
31748       case FINAL:
31749       case FORCE:
31750       case FUNCTION:
31751       case GLOBAL:
31752       case HASH:
31753       case HEAP:
31754       case HOUR:
31755       case IMMEDIATE:
31756       case INDICES:
31757       case INDEXTYPE:
31758       case INDICATOR:
31759       case INSTANTIABLE:
31760       case INTERVAL:
31761       case INVALIDATE:
31762       case ISOLATION:
31763       case JAVA:
31764       case LEVEL:
31765       case LIMIT:
31766       case MAP:
31767       case MAX:
31768       case MEMBER:
31769       case MERGE:
31770       case MIN:
31771       case MINUTE:
31772       case MLSLABEL:
31773       case MODIFY:
31774       case MONTH:
31775       case NATURAL:
31776       case NEW:
31777       case NO:
31778       case NONEDITIONABLE:
31779       case NULLIF:
31780       case OBJECT:
31781       case OID:
31782       case OPAQUE:
31783       case OPEN:
31784       case ORGANIZATION:
31785       case OTHERS:
31786       case OVERRIDING:
31787       case PACKAGE:
31788       case PARTITION:
31789       case PRESERVE:
31790       case PROCEDURE:
31791       case RANGE:
31792       case REAL:
31793       case RECORD:
31794       case REF:
31795       case RELEASE:
31796       case RELIES_ON:
31797       case RENAME:
31798       case RESULT:
31799       case RETURN:
31800       case RETURNING:
31801       case REVERSE:
31802       case ROLLBACK:
31803       case ROW:
31804       case ROWS:
31805       case ROWID:
31806       case ROWNUM:
31807       case SAVE:
31808       case SAVEPOINT:
31809       case SECOND:
31810       case SELF:
31811       case SET:
31812       case SPACE:
31813       case STATIC:
31814       case SUBTYPE:
31815       case SUBSTITUTABLE:
31816       case SUCCESSFUL:
31817       case SYS_REFCURSOR:
31818       case TEMPORARY:
31819       case TIME:
31820       case TIMESTAMP:
31821       case TIMEZONE_REGION:
31822       case TIMEZONE_ABBR:
31823       case TIMEZONE_MINUTE:
31824       case TIMEZONE_HOUR:
31825       case TRANSACTION:
31826       case TRUE:
31827       case UNDER:
31828       case USING:
31829       case YES:
31830       case SHOW:
31831       case A:
31832       case DOUBLE:
31833       case DEC:
31834       case PRECISION:
31835       case NUMERIC:
31836       case NCHAR:
31837       case NVARCHAR2:
31838       case UROWID:
31839       case VARRAY:
31840       case VARYING:
31841       case BFILE:
31842       case BLOB:
31843       case CLOB:
31844       case NCLOB:
31845       case YEAR:
31846       case LOCAL:
31847       case ZONE:
31848       case CHARACTER:
31849       case AFTER:
31850       case BEFORE:
31851       case OLD:
31852       case PARENT:
31853       case ANALYZE:
31854       case ASSOCIATE:
31855       case AUDIT:
31856       case COMPOUND:
31857       case DATABASE:
31858       case CALL:
31859       case DDL:
31860       case DISASSOCIATE:
31861       case EACH:
31862       case FOLLOWS:
31863       case LOGOFF:
31864       case LOGON:
31865       case NESTED:
31866       case NOAUDIT:
31867       case SCHEMA:
31868       case SERVERERROR:
31869       case SHUTDOWN:
31870       case STARTUP:
31871       case STATEMENT:
31872       case STATISTICS:
31873       case SUSPEND:
31874       case TRUNCATE:
31875       case WRAPPED:
31876       case LIBRARY:
31877       case NAME:
31878       case STRUCT:
31879       case CONTEXT:
31880       case PARAMETERS:
31881       case LENGTH:
31882       case TDO:
31883       case MAXLEN:
31884       case CHARSETID:
31885       case CHARSETFORM:
31886       case ACCEPT:
31887       case ACCESSIBLE:
31888       case COPY:
31889       case DEFINE:
31890       case DISCONNECT:
31891       case HOST:
31892       case PRINT:
31893       case QUIT:
31894       case REMARK:
31895       case UNDEFINE:
31896       case VARIABLE:
31897       case WHENEVER:
31898       case ATTACH:
31899       case CAST:
31900       case TREAT:
31901       case TRIM:
31902       case LEFT:
31903       case RIGHT:
31904       case BOTH:
31905       case EMPTY:
31906       case MULTISET:
31907       case SUBMULTISET:
31908       case LEADING:
31909       case TRAILING:
31910       case CHAR_CS:
31911       case NCHAR_CS:
31912       case DBTIMEZONE:
31913       case SESSIONTIMEZONE:
31914       case AUTHENTICATED:
31915       case LINK:
31916       case SHARED:
31917       case DIRECTORY:
31918       case USER:
31919         KEYWORD_UNRESERVED();
31920         break;
31921       case BODY:
31922         jj_consume_token(BODY);
31923         break;
31924       case MOD:
31925         jj_consume_token(MOD);
31926         break;
31927       case OPERATOR:
31928         jj_consume_token(OPERATOR);
31929         break;
31930       case PRIVATE:
31931         jj_consume_token(PRIVATE);
31932         break;
31933       case RAW:
31934         jj_consume_token(RAW);
31935         break;
31936       case REPLACE:
31937         jj_consume_token(REPLACE);
31938         break;
31939       case STRING:
31940         jj_consume_token(STRING);
31941         break;
31942       case SQL:
31943         jj_consume_token(SQL);
31944         break;
31945       case SQLCODE:
31946         jj_consume_token(SQLCODE);
31947         break;
31948       case SQLERRM:
31949         jj_consume_token(SQLERRM);
31950         break;
31951       case SYSDATE:
31952         jj_consume_token(SYSDATE);
31953         break;
31954       case TYPE:
31955         jj_consume_token(TYPE);
31956         break;
31957       case LOOP:
31958         jj_consume_token(LOOP);
31959         break;
31960       case INT:
31961         jj_consume_token(INT);
31962         break;
31963       case ARRAY:
31964         jj_consume_token(ARRAY);
31965         break;
31966       default:
31967         jj_la1[456] = jj_gen;
31968         jj_consume_token(-1);
31969         throw new ParseException();
31970       }
31971           jjtree.closeNodeScope(jjtn000, true);
31972           jjtc000 = false;
31973           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31974     } catch (Throwable jjte000) {
31975           if (jjtc000) {
31976             jjtree.clearNodeScope(jjtn000);
31977             jjtc000 = false;
31978           } else {
31979             jjtree.popNode();
31980           }
31981           if (jjte000 instanceof RuntimeException) {
31982             {if (true) throw (RuntimeException)jjte000;}
31983           }
31984           if (jjte000 instanceof ParseException) {
31985             {if (true) throw (ParseException)jjte000;}
31986           }
31987           {if (true) throw (Error)jjte000;}
31988     } finally {
31989           if (jjtc000) {
31990             jjtree.closeNodeScope(jjtn000, true);
31991           }
31992     }
31993     throw new Error("Missing return statement in function");
31994   }
31995 
31996 /**
31997  * 2006-05-20 - Matthias Hendler - added <LIMIT>
31998  */
31999   final public ASTQualifiedID QualifiedID() throws ParseException {
32000                                /*@bgen(jjtree) QualifiedID */
32001   ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
32002   boolean jjtc000 = true;
32003   jjtree.openNodeScope(jjtn000);
32004     try {
32005       switch (jj_nt.kind) {
32006       case IDENTIFIER:
32007         jj_consume_token(IDENTIFIER);
32008         break;
32009       case QUOTED_LITERAL:
32010         jj_consume_token(QUOTED_LITERAL);
32011         break;
32012       case DEFINER:
32013       case CURRENT_USER:
32014       case LANGUAGE:
32015       case INLINE:
32016       case ADD:
32017       case AGGREGATE:
32018       case AT:
32019       case ATTRIBUTE:
32020       case AUTHID:
32021       case BULK:
32022       case BYTE:
32023       case CASCADE:
32024       case CLOSE:
32025       case COALESCE:
32026       case COLLECT:
32027       case COLUMN:
32028       case COMMENT:
32029       case COMMIT:
32030       case CONSTRUCTOR:
32031       case CONTINUE:
32032       case CONVERT:
32033       case CURRENT:
32034       case CURSOR:
32035       case DATA:
32036       case DAY:
32037       case DISABLE:
32038       case EDITIONABLE:
32039       case ELEMENT:
32040       case ENABLE:
32041       case ESCAPE:
32042       case EXCEPT:
32043       case EXCEPTIONS:
32044       case EXIT:
32045       case EXTERNAL:
32046       case EXTENDS:
32047       case EXTRACT:
32048       case FALSE:
32049       case FINAL:
32050       case FORCE:
32051       case FUNCTION:
32052       case GLOBAL:
32053       case HASH:
32054       case HEAP:
32055       case HOUR:
32056       case IMMEDIATE:
32057       case INDICES:
32058       case INDEXTYPE:
32059       case INDICATOR:
32060       case INSTANTIABLE:
32061       case INTERVAL:
32062       case INVALIDATE:
32063       case ISOLATION:
32064       case JAVA:
32065       case LEVEL:
32066       case LIMIT:
32067       case MAP:
32068       case MAX:
32069       case MEMBER:
32070       case MERGE:
32071       case MIN:
32072       case MINUTE:
32073       case MLSLABEL:
32074       case MODIFY:
32075       case MONTH:
32076       case NATURAL:
32077       case NEW:
32078       case NO:
32079       case NONEDITIONABLE:
32080       case NULLIF:
32081       case OBJECT:
32082       case OID:
32083       case OPAQUE:
32084       case OPEN:
32085       case ORGANIZATION:
32086       case OTHERS:
32087       case OVERRIDING:
32088       case PACKAGE:
32089       case PARTITION:
32090       case PRESERVE:
32091       case PROCEDURE:
32092       case RANGE:
32093       case REAL:
32094       case RECORD:
32095       case REF:
32096       case RELEASE:
32097       case RELIES_ON:
32098       case RENAME:
32099       case RESULT:
32100       case RETURN:
32101       case RETURNING:
32102       case REVERSE:
32103       case ROLLBACK:
32104       case ROW:
32105       case ROWS:
32106       case ROWID:
32107       case ROWNUM:
32108       case SAVE:
32109       case SAVEPOINT:
32110       case SECOND:
32111       case SELF:
32112       case SET:
32113       case SPACE:
32114       case STATIC:
32115       case SUBTYPE:
32116       case SUBSTITUTABLE:
32117       case SUCCESSFUL:
32118       case SYS_REFCURSOR:
32119       case TEMPORARY:
32120       case TIME:
32121       case TIMESTAMP:
32122       case TIMEZONE_REGION:
32123       case TIMEZONE_ABBR:
32124       case TIMEZONE_MINUTE:
32125       case TIMEZONE_HOUR:
32126       case TRANSACTION:
32127       case TRUE:
32128       case UNDER:
32129       case USING:
32130       case YES:
32131       case SHOW:
32132       case A:
32133       case DOUBLE:
32134       case DEC:
32135       case PRECISION:
32136       case NUMERIC:
32137       case NCHAR:
32138       case NVARCHAR2:
32139       case UROWID:
32140       case VARRAY:
32141       case VARYING:
32142       case BFILE:
32143       case BLOB:
32144       case CLOB:
32145       case NCLOB:
32146       case YEAR:
32147       case LOCAL:
32148       case ZONE:
32149       case CHARACTER:
32150       case AFTER:
32151       case BEFORE:
32152       case OLD:
32153       case PARENT:
32154       case ANALYZE:
32155       case ASSOCIATE:
32156       case AUDIT:
32157       case COMPOUND:
32158       case DATABASE:
32159       case CALL:
32160       case DDL:
32161       case DISASSOCIATE:
32162       case EACH:
32163       case FOLLOWS:
32164       case LOGOFF:
32165       case LOGON:
32166       case NESTED:
32167       case NOAUDIT:
32168       case SCHEMA:
32169       case SERVERERROR:
32170       case SHUTDOWN:
32171       case STARTUP:
32172       case STATEMENT:
32173       case STATISTICS:
32174       case SUSPEND:
32175       case TRUNCATE:
32176       case WRAPPED:
32177       case LIBRARY:
32178       case NAME:
32179       case STRUCT:
32180       case CONTEXT:
32181       case PARAMETERS:
32182       case LENGTH:
32183       case TDO:
32184       case MAXLEN:
32185       case CHARSETID:
32186       case CHARSETFORM:
32187       case ACCEPT:
32188       case ACCESSIBLE:
32189       case COPY:
32190       case DEFINE:
32191       case DISCONNECT:
32192       case HOST:
32193       case PRINT:
32194       case QUIT:
32195       case REMARK:
32196       case UNDEFINE:
32197       case VARIABLE:
32198       case WHENEVER:
32199       case ATTACH:
32200       case CAST:
32201       case TREAT:
32202       case TRIM:
32203       case LEFT:
32204       case RIGHT:
32205       case BOTH:
32206       case EMPTY:
32207       case MULTISET:
32208       case SUBMULTISET:
32209       case LEADING:
32210       case TRAILING:
32211       case CHAR_CS:
32212       case NCHAR_CS:
32213       case DBTIMEZONE:
32214       case SESSIONTIMEZONE:
32215       case AUTHENTICATED:
32216       case LINK:
32217       case SHARED:
32218       case DIRECTORY:
32219       case USER:
32220         KEYWORD_UNRESERVED();
32221         break;
32222       case REPLACE:
32223         jj_consume_token(REPLACE);
32224         break;
32225       case SERIALLY_REUSABLE:
32226         jj_consume_token(SERIALLY_REUSABLE);
32227         break;
32228       case RESTRICT_REFERENCES:
32229         jj_consume_token(RESTRICT_REFERENCES);
32230         break;
32231       case EXCEPTION_INIT:
32232         jj_consume_token(EXCEPTION_INIT);
32233         break;
32234       case AUTONOMOUS_TRANSACTION:
32235         jj_consume_token(AUTONOMOUS_TRANSACTION);
32236         break;
32237       case ARRAY:
32238         jj_consume_token(ARRAY);
32239         break;
32240       case AVG:
32241         jj_consume_token(AVG);
32242         break;
32243       case BINARY_INTEGER:
32244         jj_consume_token(BINARY_INTEGER);
32245         break;
32246       case BODY:
32247         jj_consume_token(BODY);
32248         break;
32249       case BOOLEAN:
32250         jj_consume_token(BOOLEAN);
32251         break;
32252       case CHAR:
32253         jj_consume_token(CHAR);
32254         break;
32255       case CHAR_BASE:
32256         jj_consume_token(CHAR_BASE);
32257         break;
32258       case CONSTANT:
32259         jj_consume_token(CONSTANT);
32260         break;
32261       case CURRVAL:
32262         jj_consume_token(CURRVAL);
32263         break;
32264       case DATE:
32265         jj_consume_token(DATE);
32266         break;
32267       case DECIMAL:
32268         jj_consume_token(DECIMAL);
32269         break;
32270       case DELETE:
32271         jj_consume_token(DELETE);
32272         break;
32273       case DO:
32274         jj_consume_token(DO);
32275         break;
32276       case ELSIF:
32277         jj_consume_token(ELSIF);
32278         break;
32279       case EXECUTE:
32280         jj_consume_token(EXECUTE);
32281         break;
32282       case EXISTS:
32283         jj_consume_token(EXISTS);
32284         break;
32285       case FLOAT:
32286         jj_consume_token(FLOAT);
32287         break;
32288       case FORALL:
32289         jj_consume_token(FORALL);
32290         break;
32291       case INTEGER:
32292         jj_consume_token(INTEGER);
32293         break;
32294       case INTERFACE:
32295         jj_consume_token(INTERFACE);
32296         break;
32297       case LONG:
32298         jj_consume_token(LONG);
32299         break;
32300       case LOOP:
32301         jj_consume_token(LOOP);
32302         break;
32303       case MOD:
32304         jj_consume_token(MOD);
32305         break;
32306       case NATURALN:
32307         jj_consume_token(NATURALN);
32308         break;
32309       case NEXTVAL:
32310         jj_consume_token(NEXTVAL);
32311         break;
32312       case NOCOPY:
32313         jj_consume_token(NOCOPY);
32314         break;
32315       case NUMBER:
32316         jj_consume_token(NUMBER);
32317         break;
32318       case BFILE_BASE:
32319         jj_consume_token(BFILE_BASE);
32320         break;
32321       case BLOB_BASE:
32322         jj_consume_token(BLOB_BASE);
32323         break;
32324       case CLOB_BASE:
32325         jj_consume_token(CLOB_BASE);
32326         break;
32327       case DATE_BASE:
32328         jj_consume_token(DATE_BASE);
32329         break;
32330       case NUMBER_BASE:
32331         jj_consume_token(NUMBER_BASE);
32332         break;
32333       case OCIROWID:
32334         jj_consume_token(OCIROWID);
32335         break;
32336       case OPERATOR:
32337         jj_consume_token(OPERATOR);
32338         break;
32339       case OUT:
32340         jj_consume_token(OUT);
32341         break;
32342       case PLS_INTEGER:
32343         jj_consume_token(PLS_INTEGER);
32344         break;
32345       case POSITIVE:
32346         jj_consume_token(POSITIVE);
32347         break;
32348       case POSITIVEN:
32349         jj_consume_token(POSITIVEN);
32350         break;
32351       case PRAGMA:
32352         jj_consume_token(PRAGMA);
32353         break;
32354       case PRIOR:
32355         jj_consume_token(PRIOR);
32356         break;
32357       case PRIVATE:
32358         jj_consume_token(PRIVATE);
32359         break;
32360       case PROMPT:
32361         jj_consume_token(PROMPT);
32362         break;
32363       case RAISE:
32364         jj_consume_token(RAISE);
32365         break;
32366       case RAW:
32367         jj_consume_token(RAW);
32368         break;
32369       case ROWTYPE:
32370         jj_consume_token(ROWTYPE);
32371         break;
32372       case SEPARATE:
32373         jj_consume_token(SEPARATE);
32374         break;
32375       case SMALLINT:
32376         jj_consume_token(SMALLINT);
32377         break;
32378       case SQLCODE:
32379         jj_consume_token(SQLCODE);
32380         break;
32381       case SQLERRM:
32382         jj_consume_token(SQLERRM);
32383         break;
32384       case STDDEV:
32385         jj_consume_token(STDDEV);
32386         break;
32387       case SUM:
32388         jj_consume_token(SUM);
32389         break;
32390       case SYNONYM:
32391         jj_consume_token(SYNONYM);
32392         break;
32393       case SYSDATE:
32394         jj_consume_token(SYSDATE);
32395         break;
32396       case TRIGGER:
32397         jj_consume_token(TRIGGER);
32398         break;
32399       case TYPE:
32400         jj_consume_token(TYPE);
32401         break;
32402       case UI:
32403         jj_consume_token(UI);
32404         break;
32405       case VARCHAR:
32406         jj_consume_token(VARCHAR);
32407         break;
32408       case VARCHAR2:
32409         jj_consume_token(VARCHAR2);
32410         break;
32411       case INT:
32412         jj_consume_token(INT);
32413         break;
32414       case SIGNTYPE:
32415         jj_consume_token(SIGNTYPE);
32416         break;
32417       case STRING:
32418         jj_consume_token(STRING);
32419         break;
32420       case WHILE:
32421         jj_consume_token(WHILE);
32422         break;
32423       default:
32424         jj_la1[457] = jj_gen;
32425         jj_consume_token(-1);
32426         throw new ParseException();
32427       }
32428           jjtree.closeNodeScope(jjtn000, true);
32429           jjtc000 = false;
32430           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32431     } catch (Throwable jjte000) {
32432           if (jjtc000) {
32433             jjtree.clearNodeScope(jjtn000);
32434             jjtc000 = false;
32435           } else {
32436             jjtree.popNode();
32437           }
32438           if (jjte000 instanceof RuntimeException) {
32439             {if (true) throw (RuntimeException)jjte000;}
32440           }
32441           if (jjte000 instanceof ParseException) {
32442             {if (true) throw (ParseException)jjte000;}
32443           }
32444           {if (true) throw (Error)jjte000;}
32445     } finally {
32446           if (jjtc000) {
32447             jjtree.closeNodeScope(jjtn000, true);
32448           }
32449     }
32450     throw new Error("Missing return statement in function");
32451   }
32452 
32453   final public ASTTypeKeyword TypeKeyword() throws ParseException {
32454                                /*@bgen(jjtree) TypeKeyword */
32455   ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32456   boolean jjtc000 = true;
32457   jjtree.openNodeScope(jjtn000);
32458     try {
32459       switch (jj_nt.kind) {
32460       case BFILE_BASE:
32461         jj_consume_token(BFILE_BASE);
32462         break;
32463       case BLOB_BASE:
32464         jj_consume_token(BLOB_BASE);
32465         break;
32466       case CLOB_BASE:
32467         jj_consume_token(CLOB_BASE);
32468         break;
32469       case DATE_BASE:
32470         jj_consume_token(DATE_BASE);
32471         break;
32472       case NUMBER_BASE:
32473         jj_consume_token(NUMBER_BASE);
32474         break;
32475       case BOOLEAN:
32476         jj_consume_token(BOOLEAN);
32477         break;
32478       case DATE:
32479         jj_consume_token(DATE);
32480         break;
32481       case NUMBER:
32482         jj_consume_token(NUMBER);
32483         break;
32484       case FLOAT:
32485         jj_consume_token(FLOAT);
32486         break;
32487       case REAL:
32488         jj_consume_token(REAL);
32489         break;
32490       case INTEGER:
32491         jj_consume_token(INTEGER);
32492         break;
32493       case INT:
32494         jj_consume_token(INT);
32495         break;
32496       case SMALLINT:
32497         jj_consume_token(SMALLINT);
32498         break;
32499       case DECIMAL:
32500         jj_consume_token(DECIMAL);
32501         break;
32502       case NUMERIC:
32503         jj_consume_token(NUMERIC);
32504         break;
32505       case DEC:
32506         jj_consume_token(DEC);
32507         break;
32508       case BINARY_INTEGER:
32509         jj_consume_token(BINARY_INTEGER);
32510         break;
32511       case NATURAL:
32512         jj_consume_token(NATURAL);
32513         break;
32514       case NATURALN:
32515         jj_consume_token(NATURALN);
32516         break;
32517       case POSITIVE:
32518         jj_consume_token(POSITIVE);
32519         break;
32520       case POSITIVEN:
32521         jj_consume_token(POSITIVEN);
32522         break;
32523       case SIGNTYPE:
32524         jj_consume_token(SIGNTYPE);
32525         break;
32526       case VARCHAR2:
32527         jj_consume_token(VARCHAR2);
32528         break;
32529       case VARCHAR:
32530         jj_consume_token(VARCHAR);
32531         break;
32532       case STRING:
32533         jj_consume_token(STRING);
32534         break;
32535       case LONG:
32536         jj_consume_token(LONG);
32537         break;
32538       case RAW:
32539         jj_consume_token(RAW);
32540         break;
32541       case ROWID:
32542         jj_consume_token(ROWID);
32543         break;
32544       case CHAR:
32545         jj_consume_token(CHAR);
32546         break;
32547       case CHARACTER:
32548         jj_consume_token(CHARACTER);
32549         break;
32550       case MLSLABEL:
32551         jj_consume_token(MLSLABEL);
32552         break;
32553       case BLOB:
32554         jj_consume_token(BLOB);
32555         break;
32556       case CLOB:
32557         jj_consume_token(CLOB);
32558         break;
32559       case BFILE:
32560         jj_consume_token(BFILE);
32561         break;
32562       case NCHAR:
32563         jj_consume_token(NCHAR);
32564         break;
32565       case NVARCHAR2:
32566         jj_consume_token(NVARCHAR2);
32567         break;
32568       case NCLOB:
32569         jj_consume_token(NCLOB);
32570         break;
32571       case PLS_INTEGER:
32572         jj_consume_token(PLS_INTEGER);
32573         break;
32574       case TIME:
32575         jj_consume_token(TIME);
32576         break;
32577       case TIMESTAMP:
32578         jj_consume_token(TIMESTAMP);
32579         break;
32580       case UROWID:
32581         jj_consume_token(UROWID);
32582         break;
32583       case ARRAY:
32584         jj_consume_token(ARRAY);
32585         break;
32586       case AUTHID:
32587         jj_consume_token(AUTHID);
32588         break;
32589       case ACCESSIBLE:
32590         jj_consume_token(ACCESSIBLE);
32591         jj_consume_token(CHAR_BASE);
32592         break;
32593       case CURRVAL:
32594         jj_consume_token(CURRVAL);
32595         break;
32596       case HOUR:
32597         jj_consume_token(HOUR);
32598         break;
32599       case INTERVAL:
32600         jj_consume_token(INTERVAL);
32601         break;
32602       case MONTH:
32603         jj_consume_token(MONTH);
32604         break;
32605       case OCIROWID:
32606         jj_consume_token(OCIROWID);
32607         break;
32608       case RECORD:
32609         jj_consume_token(RECORD);
32610         break;
32611       case REF:
32612         jj_consume_token(REF);
32613         break;
32614       case ROW:
32615         jj_consume_token(ROW);
32616         break;
32617       case ROWNUM:
32618         jj_consume_token(ROWNUM);
32619         break;
32620       case ROWTYPE:
32621         jj_consume_token(ROWTYPE);
32622         break;
32623       case SECOND:
32624         jj_consume_token(SECOND);
32625         break;
32626       case SET:
32627         jj_consume_token(SET);
32628         break;
32629       case TABLE:
32630         jj_consume_token(TABLE);
32631         break;
32632       case TIMEZONE_REGION:
32633         jj_consume_token(TIMEZONE_REGION);
32634         break;
32635       case TIMEZONE_ABBR:
32636         jj_consume_token(TIMEZONE_ABBR);
32637         break;
32638       case TIMEZONE_MINUTE:
32639         jj_consume_token(TIMEZONE_MINUTE);
32640         break;
32641       case TIMEZONE_HOUR:
32642         jj_consume_token(TIMEZONE_HOUR);
32643         break;
32644       case DOUBLE:
32645         jj_consume_token(DOUBLE);
32646         break;
32647       case PRECISION:
32648         jj_consume_token(PRECISION);
32649         break;
32650       case VARRAY:
32651         jj_consume_token(VARRAY);
32652         break;
32653       case YEAR:
32654         jj_consume_token(YEAR);
32655         break;
32656       case LOCAL:
32657         jj_consume_token(LOCAL);
32658         break;
32659       case WITH:
32660         jj_consume_token(WITH);
32661         break;
32662       case ZONE:
32663         jj_consume_token(ZONE);
32664         break;
32665       case JAVA_INTERFACE_CLASS:
32666         jj_consume_token(JAVA_INTERFACE_CLASS);
32667         break;
32668       case SQLDATA_CLASS:
32669         jj_consume_token(SQLDATA_CLASS);
32670         break;
32671       case CUSTOMDATUM_CLASS:
32672         jj_consume_token(CUSTOMDATUM_CLASS);
32673         break;
32674       case ORADATA_CLASS:
32675         jj_consume_token(ORADATA_CLASS);
32676         break;
32677       default:
32678         jj_la1[458] = jj_gen;
32679         jj_consume_token(-1);
32680         throw new ParseException();
32681       }
32682           jjtree.closeNodeScope(jjtn000, true);
32683           jjtc000 = false;
32684           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32685     } finally {
32686           if (jjtc000) {
32687             jjtree.closeNodeScope(jjtn000, true);
32688           }
32689     }
32690     throw new Error("Missing return statement in function");
32691   }
32692 
32693   final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32694                                              /*@bgen(jjtree) JavaInterfaceClass */
32695   ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32696   boolean jjtc000 = true;
32697   jjtree.openNodeScope(jjtn000);
32698     try {
32699       switch (jj_nt.kind) {
32700       case SQLDATA_CLASS:
32701         jj_consume_token(SQLDATA_CLASS);
32702         break;
32703       case CUSTOMDATUM_CLASS:
32704         jj_consume_token(CUSTOMDATUM_CLASS);
32705         break;
32706       case ORADATA_CLASS:
32707         jj_consume_token(ORADATA_CLASS);
32708         break;
32709       default:
32710         jj_la1[459] = jj_gen;
32711         jj_consume_token(-1);
32712         throw new ParseException();
32713       }
32714           jjtree.closeNodeScope(jjtn000, true);
32715           jjtc000 = false;
32716           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32717     } finally {
32718           if (jjtc000) {
32719             jjtree.closeNodeScope(jjtn000, true);
32720           }
32721     }
32722     throw new Error("Missing return statement in function");
32723   }
32724 
32725 /**
32726  * Tests, if the new Token if type ID is identical to the old Token of type ID.
32727  * 
32728  * 2006-05-18 - Matthias Hendler - added: Just for understanding javacc and not used,
32729  *                                        cause to many closing ENDs (IDENTIFIER) were mistyped.
32730  */
32731   final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32732  /*@bgen(jjtree) EqualsOldIDNewID */
32733         ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32734         boolean jjtc000 = true;
32735         jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32736         Token oldIDToken;
32737         Token newIDToken;
32738     try {
32739       newID = ID();
32740           jjtree.closeNodeScope(jjtn000, true);
32741           jjtc000 = false;
32742                 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32743                 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32744                 if (oldIDToken.image.equals(newIDToken.image)) {
32745                         {if (true) return newID;}
32746                 } else {
32747                         {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32748                                 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32749                 }
32750     } catch (Throwable jjte000) {
32751           if (jjtc000) {
32752             jjtree.clearNodeScope(jjtn000);
32753             jjtc000 = false;
32754           } else {
32755             jjtree.popNode();
32756           }
32757           if (jjte000 instanceof RuntimeException) {
32758             {if (true) throw (RuntimeException)jjte000;}
32759           }
32760           if (jjte000 instanceof ParseException) {
32761             {if (true) throw (ParseException)jjte000;}
32762           }
32763           {if (true) throw (Error)jjte000;}
32764     } finally {
32765           if (jjtc000) {
32766             jjtree.closeNodeScope(jjtn000, true);
32767           }
32768     }
32769     throw new Error("Missing return statement in function");
32770   }
32771 
32772   private boolean jj_2_1(int xla) {
32773     jj_la = xla; jj_lastpos = jj_scanpos = token;
32774     try { return !jj_3_1(); }
32775     catch(LookaheadSuccess ls) { return true; }
32776     finally { jj_save(0, xla); }
32777   }
32778 
32779   private boolean jj_2_2(int xla) {
32780     jj_la = xla; jj_lastpos = jj_scanpos = token;
32781     try { return !jj_3_2(); }
32782     catch(LookaheadSuccess ls) { return true; }
32783     finally { jj_save(1, xla); }
32784   }
32785 
32786   private boolean jj_2_3(int xla) {
32787     jj_la = xla; jj_lastpos = jj_scanpos = token;
32788     try { return !jj_3_3(); }
32789     catch(LookaheadSuccess ls) { return true; }
32790     finally { jj_save(2, xla); }
32791   }
32792 
32793   private boolean jj_2_4(int xla) {
32794     jj_la = xla; jj_lastpos = jj_scanpos = token;
32795     try { return !jj_3_4(); }
32796     catch(LookaheadSuccess ls) { return true; }
32797     finally { jj_save(3, xla); }
32798   }
32799 
32800   private boolean jj_2_5(int xla) {
32801     jj_la = xla; jj_lastpos = jj_scanpos = token;
32802     try { return !jj_3_5(); }
32803     catch(LookaheadSuccess ls) { return true; }
32804     finally { jj_save(4, xla); }
32805   }
32806 
32807   private boolean jj_2_6(int xla) {
32808     jj_la = xla; jj_lastpos = jj_scanpos = token;
32809     try { return !jj_3_6(); }
32810     catch(LookaheadSuccess ls) { return true; }
32811     finally { jj_save(5, xla); }
32812   }
32813 
32814   private boolean jj_2_7(int xla) {
32815     jj_la = xla; jj_lastpos = jj_scanpos = token;
32816     try { return !jj_3_7(); }
32817     catch(LookaheadSuccess ls) { return true; }
32818     finally { jj_save(6, xla); }
32819   }
32820 
32821   private boolean jj_2_8(int xla) {
32822     jj_la = xla; jj_lastpos = jj_scanpos = token;
32823     try { return !jj_3_8(); }
32824     catch(LookaheadSuccess ls) { return true; }
32825     finally { jj_save(7, xla); }
32826   }
32827 
32828   private boolean jj_2_9(int xla) {
32829     jj_la = xla; jj_lastpos = jj_scanpos = token;
32830     try { return !jj_3_9(); }
32831     catch(LookaheadSuccess ls) { return true; }
32832     finally { jj_save(8, xla); }
32833   }
32834 
32835   private boolean jj_2_10(int xla) {
32836     jj_la = xla; jj_lastpos = jj_scanpos = token;
32837     try { return !jj_3_10(); }
32838     catch(LookaheadSuccess ls) { return true; }
32839     finally { jj_save(9, xla); }
32840   }
32841 
32842   private boolean jj_2_11(int xla) {
32843     jj_la = xla; jj_lastpos = jj_scanpos = token;
32844     try { return !jj_3_11(); }
32845     catch(LookaheadSuccess ls) { return true; }
32846     finally { jj_save(10, xla); }
32847   }
32848 
32849   private boolean jj_2_12(int xla) {
32850     jj_la = xla; jj_lastpos = jj_scanpos = token;
32851     try { return !jj_3_12(); }
32852     catch(LookaheadSuccess ls) { return true; }
32853     finally { jj_save(11, xla); }
32854   }
32855 
32856   private boolean jj_2_13(int xla) {
32857     jj_la = xla; jj_lastpos = jj_scanpos = token;
32858     try { return !jj_3_13(); }
32859     catch(LookaheadSuccess ls) { return true; }
32860     finally { jj_save(12, xla); }
32861   }
32862 
32863   private boolean jj_2_14(int xla) {
32864     jj_la = xla; jj_lastpos = jj_scanpos = token;
32865     try { return !jj_3_14(); }
32866     catch(LookaheadSuccess ls) { return true; }
32867     finally { jj_save(13, xla); }
32868   }
32869 
32870   private boolean jj_2_15(int xla) {
32871     jj_la = xla; jj_lastpos = jj_scanpos = token;
32872     try { return !jj_3_15(); }
32873     catch(LookaheadSuccess ls) { return true; }
32874     finally { jj_save(14, xla); }
32875   }
32876 
32877   private boolean jj_2_16(int xla) {
32878     jj_la = xla; jj_lastpos = jj_scanpos = token;
32879     try { return !jj_3_16(); }
32880     catch(LookaheadSuccess ls) { return true; }
32881     finally { jj_save(15, xla); }
32882   }
32883 
32884   private boolean jj_2_17(int xla) {
32885     jj_la = xla; jj_lastpos = jj_scanpos = token;
32886     try { return !jj_3_17(); }
32887     catch(LookaheadSuccess ls) { return true; }
32888     finally { jj_save(16, xla); }
32889   }
32890 
32891   private boolean jj_2_18(int xla) {
32892     jj_la = xla; jj_lastpos = jj_scanpos = token;
32893     try { return !jj_3_18(); }
32894     catch(LookaheadSuccess ls) { return true; }
32895     finally { jj_save(17, xla); }
32896   }
32897 
32898   private boolean jj_2_19(int xla) {
32899     jj_la = xla; jj_lastpos = jj_scanpos = token;
32900     try { return !jj_3_19(); }
32901     catch(LookaheadSuccess ls) { return true; }
32902     finally { jj_save(18, xla); }
32903   }
32904 
32905   private boolean jj_2_20(int xla) {
32906     jj_la = xla; jj_lastpos = jj_scanpos = token;
32907     try { return !jj_3_20(); }
32908     catch(LookaheadSuccess ls) { return true; }
32909     finally { jj_save(19, xla); }
32910   }
32911 
32912   private boolean jj_2_21(int xla) {
32913     jj_la = xla; jj_lastpos = jj_scanpos = token;
32914     try { return !jj_3_21(); }
32915     catch(LookaheadSuccess ls) { return true; }
32916     finally { jj_save(20, xla); }
32917   }
32918 
32919   private boolean jj_2_22(int xla) {
32920     jj_la = xla; jj_lastpos = jj_scanpos = token;
32921     try { return !jj_3_22(); }
32922     catch(LookaheadSuccess ls) { return true; }
32923     finally { jj_save(21, xla); }
32924   }
32925 
32926   private boolean jj_2_23(int xla) {
32927     jj_la = xla; jj_lastpos = jj_scanpos = token;
32928     try { return !jj_3_23(); }
32929     catch(LookaheadSuccess ls) { return true; }
32930     finally { jj_save(22, xla); }
32931   }
32932 
32933   private boolean jj_2_24(int xla) {
32934     jj_la = xla; jj_lastpos = jj_scanpos = token;
32935     try { return !jj_3_24(); }
32936     catch(LookaheadSuccess ls) { return true; }
32937     finally { jj_save(23, xla); }
32938   }
32939 
32940   private boolean jj_2_25(int xla) {
32941     jj_la = xla; jj_lastpos = jj_scanpos = token;
32942     try { return !jj_3_25(); }
32943     catch(LookaheadSuccess ls) { return true; }
32944     finally { jj_save(24, xla); }
32945   }
32946 
32947   private boolean jj_2_26(int xla) {
32948     jj_la = xla; jj_lastpos = jj_scanpos = token;
32949     try { return !jj_3_26(); }
32950     catch(LookaheadSuccess ls) { return true; }
32951     finally { jj_save(25, xla); }
32952   }
32953 
32954   private boolean jj_2_27(int xla) {
32955     jj_la = xla; jj_lastpos = jj_scanpos = token;
32956     try { return !jj_3_27(); }
32957     catch(LookaheadSuccess ls) { return true; }
32958     finally { jj_save(26, xla); }
32959   }
32960 
32961   private boolean jj_2_28(int xla) {
32962     jj_la = xla; jj_lastpos = jj_scanpos = token;
32963     try { return !jj_3_28(); }
32964     catch(LookaheadSuccess ls) { return true; }
32965     finally { jj_save(27, xla); }
32966   }
32967 
32968   private boolean jj_2_29(int xla) {
32969     jj_la = xla; jj_lastpos = jj_scanpos = token;
32970     try { return !jj_3_29(); }
32971     catch(LookaheadSuccess ls) { return true; }
32972     finally { jj_save(28, xla); }
32973   }
32974 
32975   private boolean jj_2_30(int xla) {
32976     jj_la = xla; jj_lastpos = jj_scanpos = token;
32977     try { return !jj_3_30(); }
32978     catch(LookaheadSuccess ls) { return true; }
32979     finally { jj_save(29, xla); }
32980   }
32981 
32982   private boolean jj_2_31(int xla) {
32983     jj_la = xla; jj_lastpos = jj_scanpos = token;
32984     try { return !jj_3_31(); }
32985     catch(LookaheadSuccess ls) { return true; }
32986     finally { jj_save(30, xla); }
32987   }
32988 
32989   private boolean jj_2_32(int xla) {
32990     jj_la = xla; jj_lastpos = jj_scanpos = token;
32991     try { return !jj_3_32(); }
32992     catch(LookaheadSuccess ls) { return true; }
32993     finally { jj_save(31, xla); }
32994   }
32995 
32996   private boolean jj_2_33(int xla) {
32997     jj_la = xla; jj_lastpos = jj_scanpos = token;
32998     try { return !jj_3_33(); }
32999     catch(LookaheadSuccess ls) { return true; }
33000     finally { jj_save(32, xla); }
33001   }
33002 
33003   private boolean jj_2_34(int xla) {
33004     jj_la = xla; jj_lastpos = jj_scanpos = token;
33005     try { return !jj_3_34(); }
33006     catch(LookaheadSuccess ls) { return true; }
33007     finally { jj_save(33, xla); }
33008   }
33009 
33010   private boolean jj_2_35(int xla) {
33011     jj_la = xla; jj_lastpos = jj_scanpos = token;
33012     try { return !jj_3_35(); }
33013     catch(LookaheadSuccess ls) { return true; }
33014     finally { jj_save(34, xla); }
33015   }
33016 
33017   private boolean jj_2_36(int xla) {
33018     jj_la = xla; jj_lastpos = jj_scanpos = token;
33019     try { return !jj_3_36(); }
33020     catch(LookaheadSuccess ls) { return true; }
33021     finally { jj_save(35, xla); }
33022   }
33023 
33024   private boolean jj_2_37(int xla) {
33025     jj_la = xla; jj_lastpos = jj_scanpos = token;
33026     try { return !jj_3_37(); }
33027     catch(LookaheadSuccess ls) { return true; }
33028     finally { jj_save(36, xla); }
33029   }
33030 
33031   private boolean jj_2_38(int xla) {
33032     jj_la = xla; jj_lastpos = jj_scanpos = token;
33033     try { return !jj_3_38(); }
33034     catch(LookaheadSuccess ls) { return true; }
33035     finally { jj_save(37, xla); }
33036   }
33037 
33038   private boolean jj_2_39(int xla) {
33039     jj_la = xla; jj_lastpos = jj_scanpos = token;
33040     try { return !jj_3_39(); }
33041     catch(LookaheadSuccess ls) { return true; }
33042     finally { jj_save(38, xla); }
33043   }
33044 
33045   private boolean jj_2_40(int xla) {
33046     jj_la = xla; jj_lastpos = jj_scanpos = token;
33047     try { return !jj_3_40(); }
33048     catch(LookaheadSuccess ls) { return true; }
33049     finally { jj_save(39, xla); }
33050   }
33051 
33052   private boolean jj_2_41(int xla) {
33053     jj_la = xla; jj_lastpos = jj_scanpos = token;
33054     try { return !jj_3_41(); }
33055     catch(LookaheadSuccess ls) { return true; }
33056     finally { jj_save(40, xla); }
33057   }
33058 
33059   private boolean jj_2_42(int xla) {
33060     jj_la = xla; jj_lastpos = jj_scanpos = token;
33061     try { return !jj_3_42(); }
33062     catch(LookaheadSuccess ls) { return true; }
33063     finally { jj_save(41, xla); }
33064   }
33065 
33066   private boolean jj_2_43(int xla) {
33067     jj_la = xla; jj_lastpos = jj_scanpos = token;
33068     try { return !jj_3_43(); }
33069     catch(LookaheadSuccess ls) { return true; }
33070     finally { jj_save(42, xla); }
33071   }
33072 
33073   private boolean jj_2_44(int xla) {
33074     jj_la = xla; jj_lastpos = jj_scanpos = token;
33075     try { return !jj_3_44(); }
33076     catch(LookaheadSuccess ls) { return true; }
33077     finally { jj_save(43, xla); }
33078   }
33079 
33080   private boolean jj_2_45(int xla) {
33081     jj_la = xla; jj_lastpos = jj_scanpos = token;
33082     try { return !jj_3_45(); }
33083     catch(LookaheadSuccess ls) { return true; }
33084     finally { jj_save(44, xla); }
33085   }
33086 
33087   private boolean jj_2_46(int xla) {
33088     jj_la = xla; jj_lastpos = jj_scanpos = token;
33089     try { return !jj_3_46(); }
33090     catch(LookaheadSuccess ls) { return true; }
33091     finally { jj_save(45, xla); }
33092   }
33093 
33094   private boolean jj_2_47(int xla) {
33095     jj_la = xla; jj_lastpos = jj_scanpos = token;
33096     try { return !jj_3_47(); }
33097     catch(LookaheadSuccess ls) { return true; }
33098     finally { jj_save(46, xla); }
33099   }
33100 
33101   private boolean jj_2_48(int xla) {
33102     jj_la = xla; jj_lastpos = jj_scanpos = token;
33103     try { return !jj_3_48(); }
33104     catch(LookaheadSuccess ls) { return true; }
33105     finally { jj_save(47, xla); }
33106   }
33107 
33108   private boolean jj_2_49(int xla) {
33109     jj_la = xla; jj_lastpos = jj_scanpos = token;
33110     try { return !jj_3_49(); }
33111     catch(LookaheadSuccess ls) { return true; }
33112     finally { jj_save(48, xla); }
33113   }
33114 
33115   private boolean jj_2_50(int xla) {
33116     jj_la = xla; jj_lastpos = jj_scanpos = token;
33117     try { return !jj_3_50(); }
33118     catch(LookaheadSuccess ls) { return true; }
33119     finally { jj_save(49, xla); }
33120   }
33121 
33122   private boolean jj_2_51(int xla) {
33123     jj_la = xla; jj_lastpos = jj_scanpos = token;
33124     try { return !jj_3_51(); }
33125     catch(LookaheadSuccess ls) { return true; }
33126     finally { jj_save(50, xla); }
33127   }
33128 
33129   private boolean jj_2_52(int xla) {
33130     jj_la = xla; jj_lastpos = jj_scanpos = token;
33131     try { return !jj_3_52(); }
33132     catch(LookaheadSuccess ls) { return true; }
33133     finally { jj_save(51, xla); }
33134   }
33135 
33136   private boolean jj_2_53(int xla) {
33137     jj_la = xla; jj_lastpos = jj_scanpos = token;
33138     try { return !jj_3_53(); }
33139     catch(LookaheadSuccess ls) { return true; }
33140     finally { jj_save(52, xla); }
33141   }
33142 
33143   private boolean jj_2_54(int xla) {
33144     jj_la = xla; jj_lastpos = jj_scanpos = token;
33145     try { return !jj_3_54(); }
33146     catch(LookaheadSuccess ls) { return true; }
33147     finally { jj_save(53, xla); }
33148   }
33149 
33150   private boolean jj_2_55(int xla) {
33151     jj_la = xla; jj_lastpos = jj_scanpos = token;
33152     try { return !jj_3_55(); }
33153     catch(LookaheadSuccess ls) { return true; }
33154     finally { jj_save(54, xla); }
33155   }
33156 
33157   private boolean jj_2_56(int xla) {
33158     jj_la = xla; jj_lastpos = jj_scanpos = token;
33159     try { return !jj_3_56(); }
33160     catch(LookaheadSuccess ls) { return true; }
33161     finally { jj_save(55, xla); }
33162   }
33163 
33164   private boolean jj_2_57(int xla) {
33165     jj_la = xla; jj_lastpos = jj_scanpos = token;
33166     try { return !jj_3_57(); }
33167     catch(LookaheadSuccess ls) { return true; }
33168     finally { jj_save(56, xla); }
33169   }
33170 
33171   private boolean jj_2_58(int xla) {
33172     jj_la = xla; jj_lastpos = jj_scanpos = token;
33173     try { return !jj_3_58(); }
33174     catch(LookaheadSuccess ls) { return true; }
33175     finally { jj_save(57, xla); }
33176   }
33177 
33178   private boolean jj_2_59(int xla) {
33179     jj_la = xla; jj_lastpos = jj_scanpos = token;
33180     try { return !jj_3_59(); }
33181     catch(LookaheadSuccess ls) { return true; }
33182     finally { jj_save(58, xla); }
33183   }
33184 
33185   private boolean jj_2_60(int xla) {
33186     jj_la = xla; jj_lastpos = jj_scanpos = token;
33187     try { return !jj_3_60(); }
33188     catch(LookaheadSuccess ls) { return true; }
33189     finally { jj_save(59, xla); }
33190   }
33191 
33192   private boolean jj_2_61(int xla) {
33193     jj_la = xla; jj_lastpos = jj_scanpos = token;
33194     try { return !jj_3_61(); }
33195     catch(LookaheadSuccess ls) { return true; }
33196     finally { jj_save(60, xla); }
33197   }
33198 
33199   private boolean jj_2_62(int xla) {
33200     jj_la = xla; jj_lastpos = jj_scanpos = token;
33201     try { return !jj_3_62(); }
33202     catch(LookaheadSuccess ls) { return true; }
33203     finally { jj_save(61, xla); }
33204   }
33205 
33206   private boolean jj_2_63(int xla) {
33207     jj_la = xla; jj_lastpos = jj_scanpos = token;
33208     try { return !jj_3_63(); }
33209     catch(LookaheadSuccess ls) { return true; }
33210     finally { jj_save(62, xla); }
33211   }
33212 
33213   private boolean jj_2_64(int xla) {
33214     jj_la = xla; jj_lastpos = jj_scanpos = token;
33215     try { return !jj_3_64(); }
33216     catch(LookaheadSuccess ls) { return true; }
33217     finally { jj_save(63, xla); }
33218   }
33219 
33220   private boolean jj_2_65(int xla) {
33221     jj_la = xla; jj_lastpos = jj_scanpos = token;
33222     try { return !jj_3_65(); }
33223     catch(LookaheadSuccess ls) { return true; }
33224     finally { jj_save(64, xla); }
33225   }
33226 
33227   private boolean jj_2_66(int xla) {
33228     jj_la = xla; jj_lastpos = jj_scanpos = token;
33229     try { return !jj_3_66(); }
33230     catch(LookaheadSuccess ls) { return true; }
33231     finally { jj_save(65, xla); }
33232   }
33233 
33234   private boolean jj_2_67(int xla) {
33235     jj_la = xla; jj_lastpos = jj_scanpos = token;
33236     try { return !jj_3_67(); }
33237     catch(LookaheadSuccess ls) { return true; }
33238     finally { jj_save(66, xla); }
33239   }
33240 
33241   private boolean jj_2_68(int xla) {
33242     jj_la = xla; jj_lastpos = jj_scanpos = token;
33243     try { return !jj_3_68(); }
33244     catch(LookaheadSuccess ls) { return true; }
33245     finally { jj_save(67, xla); }
33246   }
33247 
33248   private boolean jj_2_69(int xla) {
33249     jj_la = xla; jj_lastpos = jj_scanpos = token;
33250     try { return !jj_3_69(); }
33251     catch(LookaheadSuccess ls) { return true; }
33252     finally { jj_save(68, xla); }
33253   }
33254 
33255   private boolean jj_2_70(int xla) {
33256     jj_la = xla; jj_lastpos = jj_scanpos = token;
33257     try { return !jj_3_70(); }
33258     catch(LookaheadSuccess ls) { return true; }
33259     finally { jj_save(69, xla); }
33260   }
33261 
33262   private boolean jj_2_71(int xla) {
33263     jj_la = xla; jj_lastpos = jj_scanpos = token;
33264     try { return !jj_3_71(); }
33265     catch(LookaheadSuccess ls) { return true; }
33266     finally { jj_save(70, xla); }
33267   }
33268 
33269   private boolean jj_2_72(int xla) {
33270     jj_la = xla; jj_lastpos = jj_scanpos = token;
33271     try { return !jj_3_72(); }
33272     catch(LookaheadSuccess ls) { return true; }
33273     finally { jj_save(71, xla); }
33274   }
33275 
33276   private boolean jj_2_73(int xla) {
33277     jj_la = xla; jj_lastpos = jj_scanpos = token;
33278     try { return !jj_3_73(); }
33279     catch(LookaheadSuccess ls) { return true; }
33280     finally { jj_save(72, xla); }
33281   }
33282 
33283   private boolean jj_2_74(int xla) {
33284     jj_la = xla; jj_lastpos = jj_scanpos = token;
33285     try { return !jj_3_74(); }
33286     catch(LookaheadSuccess ls) { return true; }
33287     finally { jj_save(73, xla); }
33288   }
33289 
33290   private boolean jj_2_75(int xla) {
33291     jj_la = xla; jj_lastpos = jj_scanpos = token;
33292     try { return !jj_3_75(); }
33293     catch(LookaheadSuccess ls) { return true; }
33294     finally { jj_save(74, xla); }
33295   }
33296 
33297   private boolean jj_2_76(int xla) {
33298     jj_la = xla; jj_lastpos = jj_scanpos = token;
33299     try { return !jj_3_76(); }
33300     catch(LookaheadSuccess ls) { return true; }
33301     finally { jj_save(75, xla); }
33302   }
33303 
33304   private boolean jj_2_77(int xla) {
33305     jj_la = xla; jj_lastpos = jj_scanpos = token;
33306     try { return !jj_3_77(); }
33307     catch(LookaheadSuccess ls) { return true; }
33308     finally { jj_save(76, xla); }
33309   }
33310 
33311   private boolean jj_2_78(int xla) {
33312     jj_la = xla; jj_lastpos = jj_scanpos = token;
33313     try { return !jj_3_78(); }
33314     catch(LookaheadSuccess ls) { return true; }
33315     finally { jj_save(77, xla); }
33316   }
33317 
33318   private boolean jj_2_79(int xla) {
33319     jj_la = xla; jj_lastpos = jj_scanpos = token;
33320     try { return !jj_3_79(); }
33321     catch(LookaheadSuccess ls) { return true; }
33322     finally { jj_save(78, xla); }
33323   }
33324 
33325   private boolean jj_2_80(int xla) {
33326     jj_la = xla; jj_lastpos = jj_scanpos = token;
33327     try { return !jj_3_80(); }
33328     catch(LookaheadSuccess ls) { return true; }
33329     finally { jj_save(79, xla); }
33330   }
33331 
33332   private boolean jj_2_81(int xla) {
33333     jj_la = xla; jj_lastpos = jj_scanpos = token;
33334     try { return !jj_3_81(); }
33335     catch(LookaheadSuccess ls) { return true; }
33336     finally { jj_save(80, xla); }
33337   }
33338 
33339   private boolean jj_2_82(int xla) {
33340     jj_la = xla; jj_lastpos = jj_scanpos = token;
33341     try { return !jj_3_82(); }
33342     catch(LookaheadSuccess ls) { return true; }
33343     finally { jj_save(81, xla); }
33344   }
33345 
33346   private boolean jj_2_83(int xla) {
33347     jj_la = xla; jj_lastpos = jj_scanpos = token;
33348     try { return !jj_3_83(); }
33349     catch(LookaheadSuccess ls) { return true; }
33350     finally { jj_save(82, xla); }
33351   }
33352 
33353   private boolean jj_2_84(int xla) {
33354     jj_la = xla; jj_lastpos = jj_scanpos = token;
33355     try { return !jj_3_84(); }
33356     catch(LookaheadSuccess ls) { return true; }
33357     finally { jj_save(83, xla); }
33358   }
33359 
33360   private boolean jj_2_85(int xla) {
33361     jj_la = xla; jj_lastpos = jj_scanpos = token;
33362     try { return !jj_3_85(); }
33363     catch(LookaheadSuccess ls) { return true; }
33364     finally { jj_save(84, xla); }
33365   }
33366 
33367   private boolean jj_3R_269() {
33368     Token xsp;
33369     xsp = jj_scanpos;
33370     if (jj_scan_token(93)) {
33371     jj_scanpos = xsp;
33372     if (jj_scan_token(144)) {
33373     jj_scanpos = xsp;
33374     if (jj_scan_token(297)) return true;
33375     }
33376     }
33377     return false;
33378   }
33379 
33380   private boolean jj_3R_200() {
33381     if (jj_scan_token(LANGUAGE)) return true;
33382     Token xsp;
33383     xsp = jj_scanpos;
33384     if (jj_scan_token(420)) {
33385     jj_scanpos = xsp;
33386     if (jj_scan_token(154)) return true;
33387     }
33388     return false;
33389   }
33390 
33391   private boolean jj_3_77() {
33392     if (jj_3R_124()) return true;
33393     if (jj_scan_token(3)) return true;
33394     return false;
33395   }
33396 
33397   private boolean jj_3R_565() {
33398     Token xsp;
33399     xsp = jj_scanpos;
33400     if (jj_scan_token(183)) jj_scanpos = xsp;
33401     if (jj_scan_token(NULL)) return true;
33402     return false;
33403   }
33404 
33405   private boolean jj_3R_179() {
33406     Token xsp;
33407     xsp = jj_scanpos;
33408     if (jj_3_77()) jj_scanpos = xsp;
33409     if (jj_3R_124()) return true;
33410     return false;
33411   }
33412 
33413   private boolean jj_3_78() {
33414     if (jj_scan_token(NESTED)) return true;
33415     if (jj_scan_token(TABLE)) return true;
33416     return false;
33417   }
33418 
33419   private boolean jj_3R_530() {
33420     if (jj_scan_token(6)) return true;
33421     if (jj_3R_234()) return true;
33422     return false;
33423   }
33424 
33425   private boolean jj_3R_525() {
33426     if (jj_scan_token(VARYING)) return true;
33427     if (jj_scan_token(ARRAY)) return true;
33428     return false;
33429   }
33430 
33431   private boolean jj_3R_178() {
33432     if (jj_scan_token(OR)) return true;
33433     Token xsp;
33434     xsp = jj_scanpos;
33435     if (jj_3R_269()) {
33436     jj_scanpos = xsp;
33437     if (jj_3R_270()) return true;
33438     }
33439     return false;
33440   }
33441 
33442   private boolean jj_3R_529() {
33443     if (jj_scan_token(RETURN)) return true;
33444     if (jj_3R_236()) return true;
33445     return false;
33446   }
33447 
33448   private boolean jj_3R_176() {
33449     Token xsp;
33450     xsp = jj_scanpos;
33451     if (jj_scan_token(93)) {
33452     jj_scanpos = xsp;
33453     if (jj_scan_token(144)) {
33454     jj_scanpos = xsp;
33455     if (jj_scan_token(297)) return true;
33456     }
33457     }
33458     xsp = jj_scanpos;
33459     if (jj_3_74()) jj_scanpos = xsp;
33460     return false;
33461   }
33462 
33463   private boolean jj_3R_527() {
33464     if (jj_scan_token(NOT)) return true;
33465     if (jj_scan_token(NULL)) return true;
33466     return false;
33467   }
33468 
33469   private boolean jj_3R_266() {
33470     if (jj_scan_token(OR)) return true;
33471     if (jj_scan_token(REPLACE)) return true;
33472     return false;
33473   }
33474 
33475   private boolean jj_3R_123() {
33476     Token xsp;
33477     xsp = jj_scanpos;
33478     if (jj_scan_token(114)) {
33479     jj_scanpos = xsp;
33480     if (jj_3R_200()) return true;
33481     }
33482     while (true) {
33483       xsp = jj_scanpos;
33484       if (jj_3R_201()) { jj_scanpos = xsp; break; }
33485     }
33486     return false;
33487   }
33488 
33489   private boolean jj_3R_499() {
33490     if (jj_3R_236()) return true;
33491     return false;
33492   }
33493 
33494   private boolean jj_3R_175() {
33495     if (jj_scan_token(CREATE)) return true;
33496     Token xsp;
33497     xsp = jj_scanpos;
33498     if (jj_3R_266()) jj_scanpos = xsp;
33499     xsp = jj_scanpos;
33500     if (jj_3R_267()) jj_scanpos = xsp;
33501     return false;
33502   }
33503 
33504   private boolean jj_3R_498() {
33505     if (jj_scan_token(5)) return true;
33506     if (jj_3R_234()) return true;
33507     Token xsp;
33508     while (true) {
33509       xsp = jj_scanpos;
33510       if (jj_3R_530()) { jj_scanpos = xsp; break; }
33511     }
33512     if (jj_scan_token(7)) return true;
33513     return false;
33514   }
33515 
33516   private boolean jj_3R_108() {
33517     Token xsp;
33518     xsp = jj_scanpos;
33519     if (jj_3R_175()) jj_scanpos = xsp;
33520     if (jj_scan_token(TRIGGER)) return true;
33521     if (jj_3R_155()) return true;
33522     xsp = jj_scanpos;
33523     if (jj_scan_token(322)) {
33524     jj_scanpos = xsp;
33525     if (jj_scan_token(321)) {
33526     jj_scanpos = xsp;
33527     if (jj_scan_token(323)) {
33528     jj_scanpos = xsp;
33529     if (jj_scan_token(121)) return true;
33530     }
33531     }
33532     }
33533     xsp = jj_scanpos;
33534     if (jj_3R_176()) {
33535     jj_scanpos = xsp;
33536     if (jj_3R_177()) return true;
33537     }
33538     while (true) {
33539       xsp = jj_scanpos;
33540       if (jj_3R_178()) { jj_scanpos = xsp; break; }
33541     }
33542     if (jj_scan_token(ON)) return true;
33543     xsp = jj_scanpos;
33544     if (jj_scan_token(348)) {
33545     jj_scanpos = xsp;
33546     if (jj_3_78()) {
33547     jj_scanpos = xsp;
33548     if (jj_3R_179()) return true;
33549     }
33550     }
33551     return false;
33552   }
33553 
33554   private boolean jj_3R_497() {
33555     if (jj_scan_token(REF)) return true;
33556     if (jj_scan_token(CURSOR)) return true;
33557     Token xsp;
33558     xsp = jj_scanpos;
33559     if (jj_3R_529()) jj_scanpos = xsp;
33560     return false;
33561   }
33562 
33563   private boolean jj_3R_522() {
33564     if (jj_3R_124()) return true;
33565     if (jj_3R_236()) return true;
33566     Token xsp;
33567     xsp = jj_scanpos;
33568     if (jj_3R_565()) jj_scanpos = xsp;
33569     xsp = jj_scanpos;
33570     if (jj_3R_566()) jj_scanpos = xsp;
33571     return false;
33572   }
33573 
33574   private boolean jj_3R_496() {
33575     Token xsp;
33576     xsp = jj_scanpos;
33577     if (jj_scan_token(271)) {
33578     jj_scanpos = xsp;
33579     if (jj_scan_token(310)) {
33580     jj_scanpos = xsp;
33581     if (jj_3R_525()) return true;
33582     }
33583     }
33584     xsp = jj_scanpos;
33585     if (jj_3R_526()) jj_scanpos = xsp;
33586     if (jj_scan_token(OF)) return true;
33587     if (jj_3R_236()) return true;
33588     xsp = jj_scanpos;
33589     if (jj_3R_527()) jj_scanpos = xsp;
33590     xsp = jj_scanpos;
33591     if (jj_3R_528()) jj_scanpos = xsp;
33592     return false;
33593   }
33594 
33595   private boolean jj_3R_495() {
33596     if (jj_scan_token(RECORD)) return true;
33597     if (jj_scan_token(5)) return true;
33598     if (jj_3R_522()) return true;
33599     Token xsp;
33600     while (true) {
33601       xsp = jj_scanpos;
33602       if (jj_3R_524()) { jj_scanpos = xsp; break; }
33603     }
33604     if (jj_scan_token(7)) return true;
33605     return false;
33606   }
33607 
33608   private boolean jj_3R_494() {
33609     if (jj_scan_token(OBJECT)) return true;
33610     if (jj_scan_token(5)) return true;
33611     if (jj_3R_522()) return true;
33612     Token xsp;
33613     while (true) {
33614       xsp = jj_scanpos;
33615       if (jj_3R_523()) { jj_scanpos = xsp; break; }
33616     }
33617     if (jj_scan_token(7)) return true;
33618     return false;
33619   }
33620 
33621   private boolean jj_3R_645() {
33622     if (jj_3R_174()) return true;
33623     return false;
33624   }
33625 
33626   private boolean jj_3_44() {
33627     if (jj_scan_token(NEW)) return true;
33628     Token xsp;
33629     xsp = jj_scanpos;
33630     if (jj_scan_token(68)) {
33631     jj_scanpos = xsp;
33632     if (jj_scan_token(191)) {
33633     jj_scanpos = xsp;
33634     if (jj_scan_token(190)) {
33635     jj_scanpos = xsp;
33636     if (jj_scan_token(189)) {
33637     jj_scanpos = xsp;
33638     if (jj_scan_token(188)) {
33639     jj_scanpos = xsp;
33640     if (jj_scan_token(192)) return true;
33641     }
33642     }
33643     }
33644     }
33645     }
33646     return false;
33647   }
33648 
33649   private boolean jj_3R_595() {
33650     if (jj_3R_174()) return true;
33651     return false;
33652   }
33653 
33654   private boolean jj_3R_646() {
33655     Token xsp;
33656     xsp = jj_scanpos;
33657     if (jj_scan_token(137)) {
33658     jj_scanpos = xsp;
33659     if (jj_scan_token(207)) {
33660     jj_scanpos = xsp;
33661     if (jj_scan_token(138)) return true;
33662     }
33663     }
33664     return false;
33665   }
33666 
33667   private boolean jj_3R_493() {
33668     if (jj_scan_token(NOT)) return true;
33669     if (jj_scan_token(NULL)) return true;
33670     return false;
33671   }
33672 
33673   private boolean jj_3R_521() {
33674     if (jj_scan_token(RANGE)) return true;
33675     if (jj_3R_484()) return true;
33676     if (jj_scan_token(12)) return true;
33677     if (jj_3R_484()) return true;
33678     return false;
33679   }
33680 
33681   private boolean jj_3R_520() {
33682     if (jj_scan_token(5)) return true;
33683     if (jj_scan_token(IDENTIFIER)) return true;
33684     if (jj_scan_token(7)) return true;
33685     return false;
33686   }
33687 
33688   private boolean jj_3R_492() {
33689     Token xsp;
33690     xsp = jj_scanpos;
33691     if (jj_3R_520()) {
33692     jj_scanpos = xsp;
33693     if (jj_3R_521()) return true;
33694     }
33695     return false;
33696   }
33697 
33698   private boolean jj_3R_647() {
33699     if (jj_scan_token(IN)) return true;
33700     Token xsp;
33701     xsp = jj_scanpos;
33702     if (jj_scan_token(207)) jj_scanpos = xsp;
33703     return false;
33704   }
33705 
33706   private boolean jj_3R_644() {
33707     Token xsp;
33708     xsp = jj_scanpos;
33709     if (jj_3R_647()) {
33710     jj_scanpos = xsp;
33711     if (jj_scan_token(207)) return true;
33712     }
33713     return false;
33714   }
33715 
33716   private boolean jj_3R_643() {
33717     if (jj_scan_token(6)) return true;
33718     Token xsp;
33719     xsp = jj_scanpos;
33720     if (jj_3R_646()) jj_scanpos = xsp;
33721     if (jj_3R_234()) return true;
33722     return false;
33723   }
33724 
33725   private boolean jj_3R_244() {
33726     if (jj_scan_token(TYPE)) return true;
33727     if (jj_3R_120()) return true;
33728     Token xsp;
33729     xsp = jj_scanpos;
33730     if (jj_scan_token(152)) {
33731     jj_scanpos = xsp;
33732     if (jj_scan_token(51)) return true;
33733     }
33734     xsp = jj_scanpos;
33735     if (jj_3_44()) {
33736     jj_scanpos = xsp;
33737     if (jj_3R_494()) {
33738     jj_scanpos = xsp;
33739     if (jj_3R_495()) {
33740     jj_scanpos = xsp;
33741     if (jj_3R_496()) {
33742     jj_scanpos = xsp;
33743     if (jj_3R_497()) {
33744     jj_scanpos = xsp;
33745     if (jj_3R_498()) {
33746     jj_scanpos = xsp;
33747     if (jj_3R_499()) return true;
33748     }
33749     }
33750     }
33751     }
33752     }
33753     }
33754     return false;
33755   }
33756 
33757   private boolean jj_3R_641() {
33758     if (jj_scan_token(6)) return true;
33759     if (jj_3R_234()) return true;
33760     return false;
33761   }
33762 
33763   private boolean jj_3R_640() {
33764     if (jj_scan_token(6)) return true;
33765     Token xsp;
33766     xsp = jj_scanpos;
33767     if (jj_3R_644()) jj_scanpos = xsp;
33768     if (jj_3R_234()) return true;
33769     return false;
33770   }
33771 
33772   private boolean jj_3R_243() {
33773     if (jj_scan_token(SUBTYPE)) return true;
33774     if (jj_3R_120()) return true;
33775     if (jj_scan_token(IS)) return true;
33776     if (jj_3R_236()) return true;
33777     Token xsp;
33778     xsp = jj_scanpos;
33779     if (jj_3R_492()) jj_scanpos = xsp;
33780     xsp = jj_scanpos;
33781     if (jj_3R_493()) jj_scanpos = xsp;
33782     return false;
33783   }
33784 
33785   private boolean jj_3R_620() {
33786     if (jj_3R_174()) return true;
33787     return false;
33788   }
33789 
33790   private boolean jj_3R_153() {
33791     Token xsp;
33792     xsp = jj_scanpos;
33793     if (jj_3R_243()) {
33794     jj_scanpos = xsp;
33795     if (jj_3R_244()) return true;
33796     }
33797     if (jj_scan_token(4)) return true;
33798     return false;
33799   }
33800 
33801   private boolean jj_3R_556() {
33802     if (jj_scan_token(LIMIT)) return true;
33803     if (jj_3R_234()) return true;
33804     return false;
33805   }
33806 
33807   private boolean jj_3R_597() {
33808     if (jj_scan_token(CC_ELSE)) return true;
33809     Token xsp;
33810     if (jj_3R_620()) return true;
33811     while (true) {
33812       xsp = jj_scanpos;
33813       if (jj_3R_620()) { jj_scanpos = xsp; break; }
33814     }
33815     return false;
33816   }
33817 
33818   private boolean jj_3R_596() {
33819     if (jj_scan_token(CC_ELSIF)) return true;
33820     if (jj_3R_344()) return true;
33821     if (jj_scan_token(CC_THEN)) return true;
33822     Token xsp;
33823     if (jj_3R_645()) return true;
33824     while (true) {
33825       xsp = jj_scanpos;
33826       if (jj_3R_645()) { jj_scanpos = xsp; break; }
33827     }
33828     return false;
33829   }
33830 
33831   private boolean jj_3R_457() {
33832     if (jj_scan_token(CC_ERROR)) return true;
33833     if (jj_3R_234()) return true;
33834     if (jj_scan_token(CC_END)) return true;
33835     return false;
33836   }
33837 
33838   private boolean jj_3R_404() {
33839     if (jj_scan_token(INTERFACE)) return true;
33840     if (jj_scan_token(5)) return true;
33841     return false;
33842   }
33843 
33844   private boolean jj_3R_403() {
33845     if (jj_scan_token(EXCEPTION_INIT)) return true;
33846     if (jj_scan_token(5)) return true;
33847     return false;
33848   }
33849 
33850   private boolean jj_3R_456() {
33851     if (jj_scan_token(CC_IF)) return true;
33852     if (jj_3R_344()) return true;
33853     if (jj_scan_token(CC_THEN)) return true;
33854     Token xsp;
33855     while (true) {
33856       xsp = jj_scanpos;
33857       if (jj_3R_595()) { jj_scanpos = xsp; break; }
33858     }
33859     while (true) {
33860       xsp = jj_scanpos;
33861       if (jj_3R_596()) { jj_scanpos = xsp; break; }
33862     }
33863     while (true) {
33864       xsp = jj_scanpos;
33865       if (jj_3R_597()) { jj_scanpos = xsp; break; }
33866     }
33867     if (jj_scan_token(CC_END)) return true;
33868     return false;
33869   }
33870 
33871   private boolean jj_3R_618() {
33872     Token xsp;
33873     xsp = jj_scanpos;
33874     if (jj_scan_token(137)) {
33875     jj_scanpos = xsp;
33876     if (jj_scan_token(207)) {
33877     jj_scanpos = xsp;
33878     if (jj_scan_token(138)) return true;
33879     }
33880     }
33881     return false;
33882   }
33883 
33884   private boolean jj_3R_639() {
33885     if (jj_scan_token(6)) return true;
33886     if (jj_3R_295()) return true;
33887     return false;
33888   }
33889 
33890   private boolean jj_3R_421() {
33891     Token xsp;
33892     xsp = jj_scanpos;
33893     if (jj_3R_456()) {
33894     jj_scanpos = xsp;
33895     if (jj_3R_457()) return true;
33896     }
33897     return false;
33898   }
33899 
33900   private boolean jj_3R_402() {
33901     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33902     if (jj_scan_token(5)) return true;
33903     return false;
33904   }
33905 
33906   private boolean jj_3R_619() {
33907     if (jj_scan_token(IN)) return true;
33908     Token xsp;
33909     xsp = jj_scanpos;
33910     if (jj_scan_token(207)) jj_scanpos = xsp;
33911     return false;
33912   }
33913 
33914   private boolean jj_3R_594() {
33915     Token xsp;
33916     xsp = jj_scanpos;
33917     if (jj_3R_619()) {
33918     jj_scanpos = xsp;
33919     if (jj_scan_token(207)) return true;
33920     }
33921     return false;
33922   }
33923 
33924   private boolean jj_3R_554() {
33925     if (jj_scan_token(BULK)) return true;
33926     if (jj_scan_token(COLLECT)) return true;
33927     return false;
33928   }
33929 
33930   private boolean jj_3R_555() {
33931     if (jj_scan_token(6)) return true;
33932     if (jj_3R_234()) return true;
33933     return false;
33934   }
33935 
33936   private boolean jj_3R_420() {
33937     if (jj_scan_token(PIPE)) return true;
33938     if (jj_scan_token(ROW)) return true;
33939     if (jj_3R_234()) return true;
33940     return false;
33941   }
33942 
33943   private boolean jj_3R_593() {
33944     if (jj_scan_token(USING)) return true;
33945     Token xsp;
33946     xsp = jj_scanpos;
33947     if (jj_3R_618()) jj_scanpos = xsp;
33948     if (jj_3R_234()) return true;
33949     while (true) {
33950       xsp = jj_scanpos;
33951       if (jj_3R_643()) { jj_scanpos = xsp; break; }
33952     }
33953     return false;
33954   }
33955 
33956   private boolean jj_3R_559() {
33957     Token xsp;
33958     xsp = jj_scanpos;
33959     if (jj_scan_token(237)) {
33960     jj_scanpos = xsp;
33961     if (jj_scan_token(238)) return true;
33962     }
33963     if (jj_scan_token(INTO)) return true;
33964     if (jj_3R_234()) return true;
33965     while (true) {
33966       xsp = jj_scanpos;
33967       if (jj_3R_641()) { jj_scanpos = xsp; break; }
33968     }
33969     return false;
33970   }
33971 
33972   private boolean jj_3R_558() {
33973     if (jj_scan_token(USING)) return true;
33974     Token xsp;
33975     xsp = jj_scanpos;
33976     if (jj_3R_594()) jj_scanpos = xsp;
33977     if (jj_3R_234()) return true;
33978     while (true) {
33979       xsp = jj_scanpos;
33980       if (jj_3R_640()) { jj_scanpos = xsp; break; }
33981     }
33982     return false;
33983   }
33984 
33985   private boolean jj_3R_352() {
33986     if (jj_scan_token(PRAGMA)) return true;
33987     Token xsp;
33988     xsp = jj_scanpos;
33989     if (jj_scan_token(38)) {
33990     jj_scanpos = xsp;
33991     if (jj_scan_token(41)) {
33992     jj_scanpos = xsp;
33993     if (jj_3R_402()) {
33994     jj_scanpos = xsp;
33995     if (jj_3R_403()) {
33996     jj_scanpos = xsp;
33997     if (jj_3R_404()) return true;
33998     }
33999     }
34000     }
34001     }
34002     return false;
34003   }
34004 
34005   private boolean jj_3R_557() {
34006     if (jj_scan_token(INTO)) return true;
34007     if (jj_3R_295()) return true;
34008     Token xsp;
34009     while (true) {
34010       xsp = jj_scanpos;
34011       if (jj_3R_639()) { jj_scanpos = xsp; break; }
34012     }
34013     return false;
34014   }
34015 
34016   private boolean jj_3R_452() {
34017     if (jj_scan_token(WHEN)) return true;
34018     if (jj_3R_234()) return true;
34019     return false;
34020   }
34021 
34022   private boolean jj_3R_419() {
34023     if (jj_scan_token(EXECUTE)) return true;
34024     if (jj_scan_token(IMMEDIATE)) return true;
34025     if (jj_3R_234()) return true;
34026     Token xsp;
34027     xsp = jj_scanpos;
34028     if (jj_3R_557()) jj_scanpos = xsp;
34029     xsp = jj_scanpos;
34030     if (jj_3R_558()) jj_scanpos = xsp;
34031     xsp = jj_scanpos;
34032     if (jj_3R_559()) jj_scanpos = xsp;
34033     if (jj_scan_token(4)) return true;
34034     return false;
34035   }
34036 
34037   private boolean jj_3R_455() {
34038     if (jj_scan_token(FOR)) return true;
34039     if (jj_3R_234()) return true;
34040     Token xsp;
34041     xsp = jj_scanpos;
34042     if (jj_3R_593()) jj_scanpos = xsp;
34043     return false;
34044   }
34045 
34046   private boolean jj_3R_418() {
34047     if (jj_scan_token(FETCH)) return true;
34048     if (jj_3R_128()) return true;
34049     Token xsp;
34050     xsp = jj_scanpos;
34051     if (jj_3R_554()) jj_scanpos = xsp;
34052     if (jj_scan_token(INTO)) return true;
34053     if (jj_3R_234()) return true;
34054     while (true) {
34055       xsp = jj_scanpos;
34056       if (jj_3R_555()) { jj_scanpos = xsp; break; }
34057     }
34058     xsp = jj_scanpos;
34059     if (jj_3R_556()) jj_scanpos = xsp;
34060     return false;
34061   }
34062 
34063   private boolean jj_3R_209() {
34064     if (jj_scan_token(WHEN)) return true;
34065     if (jj_3R_234()) return true;
34066     return false;
34067   }
34068 
34069   private boolean jj_3R_454() {
34070     if (jj_3R_234()) return true;
34071     return false;
34072   }
34073 
34074   private boolean jj_3R_148() {
34075     if (jj_3R_124()) return true;
34076     if (jj_3R_236()) return true;
34077     return false;
34078   }
34079 
34080   private boolean jj_3R_417() {
34081     if (jj_scan_token(OPEN)) return true;
34082     Token xsp;
34083     xsp = jj_scanpos;
34084     if (jj_3R_454()) jj_scanpos = xsp;
34085     xsp = jj_scanpos;
34086     if (jj_3R_455()) jj_scanpos = xsp;
34087     return false;
34088   }
34089 
34090   private boolean jj_3R_453() {
34091     if (jj_3R_128()) return true;
34092     return false;
34093   }
34094 
34095   private boolean jj_3R_416() {
34096     if (jj_scan_token(CLOSE)) return true;
34097     if (jj_3R_128()) return true;
34098     return false;
34099   }
34100 
34101   private boolean jj_3R_451() {
34102     if (jj_3R_143()) return true;
34103     return false;
34104   }
34105 
34106   private boolean jj_3R_415() {
34107     if (jj_scan_token(RAISE)) return true;
34108     Token xsp;
34109     xsp = jj_scanpos;
34110     if (jj_3R_453()) jj_scanpos = xsp;
34111     return false;
34112   }
34113 
34114   private boolean jj_3R_208() {
34115     if (jj_3R_143()) return true;
34116     return false;
34117   }
34118 
34119   private boolean jj_3R_592() {
34120     if (jj_scan_token(12)) return true;
34121     if (jj_3R_234()) return true;
34122     return false;
34123   }
34124 
34125   private boolean jj_3R_414() {
34126     if (jj_scan_token(EXIT)) return true;
34127     Token xsp;
34128     xsp = jj_scanpos;
34129     if (jj_3R_451()) jj_scanpos = xsp;
34130     xsp = jj_scanpos;
34131     if (jj_3R_452()) jj_scanpos = xsp;
34132     return false;
34133   }
34134 
34135   private boolean jj_3R_450() {
34136     if (jj_3R_234()) return true;
34137     return false;
34138   }
34139 
34140   private boolean jj_3R_132() {
34141     if (jj_scan_token(CONTINUE)) return true;
34142     Token xsp;
34143     xsp = jj_scanpos;
34144     if (jj_3R_208()) jj_scanpos = xsp;
34145     xsp = jj_scanpos;
34146     if (jj_3R_209()) jj_scanpos = xsp;
34147     return false;
34148   }
34149 
34150   private boolean jj_3R_552() {
34151     if (jj_scan_token(SAVE)) return true;
34152     if (jj_scan_token(EXCEPTIONS)) return true;
34153     return false;
34154   }
34155 
34156   private boolean jj_3R_551() {
34157     if (jj_3R_234()) return true;
34158     Token xsp;
34159     xsp = jj_scanpos;
34160     if (jj_3R_592()) jj_scanpos = xsp;
34161     return false;
34162   }
34163 
34164   private boolean jj_3R_638() {
34165     if (jj_3R_174()) return true;
34166     return false;
34167   }
34168 
34169   private boolean jj_3R_550() {
34170     Token xsp;
34171     xsp = jj_scanpos;
34172     if (jj_scan_token(140)) {
34173     jj_scanpos = xsp;
34174     if (jj_scan_token(289)) return true;
34175     }
34176     if (jj_scan_token(OF)) return true;
34177     if (jj_3R_234()) return true;
34178     return false;
34179   }
34180 
34181   private boolean jj_3R_413() {
34182     if (jj_scan_token(RETURN)) return true;
34183     Token xsp;
34184     xsp = jj_scanpos;
34185     if (jj_3R_450()) jj_scanpos = xsp;
34186     return false;
34187   }
34188 
34189   private boolean jj_3R_412() {
34190     if (jj_scan_token(GOTO)) return true;
34191     if (jj_3R_128()) return true;
34192     return false;
34193   }
34194 
34195   private boolean jj_3R_356() {
34196     if (jj_scan_token(CASCADE)) return true;
34197     return false;
34198   }
34199 
34200   private boolean jj_3R_315() {
34201     Token xsp;
34202     xsp = jj_scanpos;
34203     if (jj_scan_token(151)) {
34204     jj_scanpos = xsp;
34205     if (jj_3R_356()) return true;
34206     }
34207     return false;
34208   }
34209 
34210   private boolean jj_3R_150() {
34211     if (jj_3R_239()) return true;
34212     return false;
34213   }
34214 
34215   private boolean jj_3R_409() {
34216     if (jj_scan_token(FORALL)) return true;
34217     if (jj_3R_448()) return true;
34218     if (jj_scan_token(IN)) return true;
34219     Token xsp;
34220     xsp = jj_scanpos;
34221     if (jj_3R_550()) {
34222     jj_scanpos = xsp;
34223     if (jj_3R_551()) return true;
34224     }
34225     xsp = jj_scanpos;
34226     if (jj_3R_552()) jj_scanpos = xsp;
34227     if (jj_3R_405()) return true;
34228     return false;
34229   }
34230 
34231   private boolean jj_3_73() {
34232     if (jj_3R_147()) return true;
34233     return false;
34234   }
34235 
34236   private boolean jj_3R_549() {
34237     if (jj_scan_token(12)) return true;
34238     if (jj_3R_234()) return true;
34239     return false;
34240   }
34241 
34242   private boolean jj_3R_149() {
34243     if (jj_scan_token(AUTHID)) return true;
34244     Token xsp;
34245     xsp = jj_scanpos;
34246     if (jj_scan_token(37)) {
34247     jj_scanpos = xsp;
34248     if (jj_scan_token(36)) return true;
34249     }
34250     return false;
34251   }
34252 
34253   private boolean jj_3R_314() {
34254     Token xsp;
34255     xsp = jj_scanpos;
34256     if (jj_scan_token(183)) jj_scanpos = xsp;
34257     xsp = jj_scanpos;
34258     if (jj_scan_token(119)) {
34259     jj_scanpos = xsp;
34260     if (jj_scan_token(145)) {
34261     jj_scanpos = xsp;
34262     if (jj_scan_token(185)) return true;
34263     }
34264     }
34265     return false;
34266   }
34267 
34268   private boolean jj_3_72() {
34269     if (jj_3R_147()) return true;
34270     return false;
34271   }
34272 
34273   private boolean jj_3R_546() {
34274     if (jj_3R_174()) return true;
34275     return false;
34276   }
34277 
34278   private boolean jj_3R_553() {
34279     if (jj_3R_174()) return true;
34280     return false;
34281   }
34282 
34283   private boolean jj_3R_448() {
34284     if (jj_3R_124()) return true;
34285     return false;
34286   }
34287 
34288   private boolean jj_3_71() {
34289     Token xsp;
34290     xsp = jj_scanpos;
34291     if (jj_3R_149()) {
34292     jj_scanpos = xsp;
34293     if (jj_3R_150()) return true;
34294     }
34295     return false;
34296   }
34297 
34298   private boolean jj_3R_313() {
34299     if (jj_scan_token(REPLACE)) return true;
34300     return false;
34301   }
34302 
34303   private boolean jj_3R_447() {
34304     if (jj_3R_124()) return true;
34305     return false;
34306   }
34307 
34308   private boolean jj_3R_548() {
34309     if (jj_3R_486()) return true;
34310     return false;
34311   }
34312 
34313   private boolean jj_3R_547() {
34314     if (jj_3R_591()) return true;
34315     return false;
34316   }
34317 
34318   private boolean jj_3R_407() {
34319     if (jj_scan_token(IF)) return true;
34320     if (jj_3R_234()) return true;
34321     if (jj_scan_token(THEN)) return true;
34322     Token xsp;
34323     if (jj_3R_546()) return true;
34324     while (true) {
34325       xsp = jj_scanpos;
34326       if (jj_3R_546()) { jj_scanpos = xsp; break; }
34327     }
34328     while (true) {
34329       xsp = jj_scanpos;
34330       if (jj_3R_547()) { jj_scanpos = xsp; break; }
34331     }
34332     xsp = jj_scanpos;
34333     if (jj_3R_548()) jj_scanpos = xsp;
34334     if (jj_scan_token(END)) return true;
34335     if (jj_scan_token(IF)) return true;
34336     return false;
34337   }
34338 
34339   private boolean jj_3R_642() {
34340     if (jj_3R_174()) return true;
34341     return false;
34342   }
34343 
34344   private boolean jj_3R_411() {
34345     if (jj_scan_token(WHILE)) return true;
34346     if (jj_3R_234()) return true;
34347     if (jj_scan_token(LOOP)) return true;
34348     Token xsp;
34349     if (jj_3R_553()) return true;
34350     while (true) {
34351       xsp = jj_scanpos;
34352       if (jj_3R_553()) { jj_scanpos = xsp; break; }
34353     }
34354     if (jj_scan_token(END)) return true;
34355     if (jj_scan_token(LOOP)) return true;
34356     xsp = jj_scanpos;
34357     if (jj_scan_token(420)) jj_scanpos = xsp;
34358     return false;
34359   }
34360 
34361   private boolean jj_3R_131() {
34362     if (jj_scan_token(LOCK)) return true;
34363     if (jj_scan_token(TABLE)) return true;
34364     return false;
34365   }
34366 
34367   private boolean jj_3R_408() {
34368     if (jj_scan_token(FOR)) return true;
34369     if (jj_3R_447()) return true;
34370     if (jj_scan_token(IN)) return true;
34371     Token xsp;
34372     xsp = jj_scanpos;
34373     if (jj_scan_token(239)) jj_scanpos = xsp;
34374     if (jj_3R_234()) return true;
34375     xsp = jj_scanpos;
34376     if (jj_3R_549()) jj_scanpos = xsp;
34377     if (jj_scan_token(LOOP)) return true;
34378     if (jj_3R_638()) return true;
34379     while (true) {
34380       xsp = jj_scanpos;
34381       if (jj_3R_638()) { jj_scanpos = xsp; break; }
34382     }
34383     if (jj_scan_token(END)) return true;
34384     if (jj_scan_token(LOOP)) return true;
34385     xsp = jj_scanpos;
34386     if (jj_scan_token(420)) jj_scanpos = xsp;
34387     return false;
34388   }
34389 
34390   private boolean jj_3R_616() {
34391     if (jj_3R_174()) return true;
34392     return false;
34393   }
34394 
34395   private boolean jj_3R_449() {
34396     if (jj_3R_174()) return true;
34397     return false;
34398   }
34399 
34400   private boolean jj_3R_410() {
34401     if (jj_scan_token(LOOP)) return true;
34402     Token xsp;
34403     if (jj_3R_449()) return true;
34404     while (true) {
34405       xsp = jj_scanpos;
34406       if (jj_3R_449()) { jj_scanpos = xsp; break; }
34407     }
34408     if (jj_scan_token(END)) return true;
34409     if (jj_scan_token(LOOP)) return true;
34410     xsp = jj_scanpos;
34411     if (jj_scan_token(420)) jj_scanpos = xsp;
34412     return false;
34413   }
34414 
34415   private boolean jj_3R_130() {
34416     if (jj_scan_token(SET)) return true;
34417     if (jj_scan_token(TRANSACTION)) return true;
34418     return false;
34419   }
34420 
34421   private boolean jj_3R_617() {
34422     if (jj_3R_174()) return true;
34423     return false;
34424   }
34425 
34426   private boolean jj_3R_591() {
34427     if (jj_scan_token(ELSIF)) return true;
34428     if (jj_3R_234()) return true;
34429     if (jj_scan_token(THEN)) return true;
34430     Token xsp;
34431     if (jj_3R_642()) return true;
34432     while (true) {
34433       xsp = jj_scanpos;
34434       if (jj_3R_642()) { jj_scanpos = xsp; break; }
34435     }
34436     return false;
34437   }
34438 
34439   private boolean jj_3R_486() {
34440     if (jj_scan_token(ELSE)) return true;
34441     Token xsp;
34442     if (jj_3R_617()) return true;
34443     while (true) {
34444       xsp = jj_scanpos;
34445       if (jj_3R_617()) { jj_scanpos = xsp; break; }
34446     }
34447     return false;
34448   }
34449 
34450   private boolean jj_3R_485() {
34451     if (jj_scan_token(WHEN)) return true;
34452     if (jj_3R_234()) return true;
34453     if (jj_scan_token(THEN)) return true;
34454     Token xsp;
34455     if (jj_3R_616()) return true;
34456     while (true) {
34457       xsp = jj_scanpos;
34458       if (jj_3R_616()) { jj_scanpos = xsp; break; }
34459     }
34460     return false;
34461   }
34462 
34463   private boolean jj_3R_444() {
34464     if (jj_3R_234()) return true;
34465     return false;
34466   }
34467 
34468   private boolean jj_3R_355() {
34469     if (jj_scan_token(DROP)) return true;
34470     return false;
34471   }
34472 
34473   private boolean jj_3R_446() {
34474     if (jj_3R_486()) return true;
34475     return false;
34476   }
34477 
34478   private boolean jj_3R_445() {
34479     if (jj_3R_485()) return true;
34480     return false;
34481   }
34482 
34483   private boolean jj_3R_406() {
34484     if (jj_scan_token(CASE)) return true;
34485     Token xsp;
34486     xsp = jj_scanpos;
34487     if (jj_3R_444()) jj_scanpos = xsp;
34488     while (true) {
34489       xsp = jj_scanpos;
34490       if (jj_3R_445()) { jj_scanpos = xsp; break; }
34491     }
34492     xsp = jj_scanpos;
34493     if (jj_3R_446()) jj_scanpos = xsp;
34494     if (jj_scan_token(END)) return true;
34495     if (jj_scan_token(CASE)) return true;
34496     xsp = jj_scanpos;
34497     if (jj_scan_token(420)) jj_scanpos = xsp;
34498     return false;
34499   }
34500 
34501   private boolean jj_3R_357() {
34502     if (jj_3R_191()) return true;
34503     return false;
34504   }
34505 
34506   private boolean jj_3R_354() {
34507     Token xsp;
34508     xsp = jj_scanpos;
34509     if (jj_scan_token(6)) jj_scanpos = xsp;
34510     xsp = jj_scanpos;
34511     if (jj_scan_token(44)) {
34512     jj_scanpos = xsp;
34513     if (jj_scan_token(170)) return true;
34514     }
34515     return false;
34516   }
34517 
34518   private boolean jj_3R_312() {
34519     Token xsp;
34520     xsp = jj_scanpos;
34521     if (jj_3R_354()) {
34522     jj_scanpos = xsp;
34523     if (jj_3R_355()) return true;
34524     }
34525     return false;
34526   }
34527 
34528   private boolean jj_3R_316() {
34529     Token xsp;
34530     if (jj_3R_357()) return true;
34531     while (true) {
34532       xsp = jj_scanpos;
34533       if (jj_3R_357()) { jj_scanpos = xsp; break; }
34534     }
34535     if (jj_3R_317()) return true;
34536     return false;
34537   }
34538 
34539   private boolean jj_3R_308() {
34540     if (jj_3R_148()) return true;
34541     return false;
34542   }
34543 
34544   private boolean jj_3R_260() {
34545     if (jj_scan_token(ALTER)) return true;
34546     if (jj_scan_token(TYPE)) return true;
34547     if (jj_3R_128()) return true;
34548     Token xsp;
34549     while (true) {
34550       xsp = jj_scanpos;
34551       if (jj_3R_312()) { jj_scanpos = xsp; break; }
34552     }
34553     xsp = jj_scanpos;
34554     if (jj_3R_313()) jj_scanpos = xsp;
34555     while (true) {
34556       xsp = jj_scanpos;
34557       if (jj_3R_314()) { jj_scanpos = xsp; break; }
34558     }
34559     xsp = jj_scanpos;
34560     if (jj_3R_315()) jj_scanpos = xsp;
34561     return false;
34562   }
34563 
34564   private boolean jj_3_70() {
34565     if (jj_3R_148()) return true;
34566     return false;
34567   }
34568 
34569   private boolean jj_3R_265() {
34570     if (jj_3R_317()) return true;
34571     return false;
34572   }
34573 
34574   private boolean jj_3R_264() {
34575     if (jj_3R_316()) return true;
34576     return false;
34577   }
34578 
34579   private boolean jj_3R_261() {
34580     if (jj_3R_260()) return true;
34581     return false;
34582   }
34583 
34584   private boolean jj_3R_174() {
34585     Token xsp;
34586     xsp = jj_scanpos;
34587     if (jj_3R_264()) {
34588     jj_scanpos = xsp;
34589     if (jj_3R_265()) return true;
34590     }
34591     return false;
34592   }
34593 
34594   private boolean jj_3R_168() {
34595     Token xsp;
34596     xsp = jj_scanpos;
34597     if (jj_scan_token(4)) {
34598     jj_scanpos = xsp;
34599     if (jj_scan_token(1)) return true;
34600     }
34601     while (true) {
34602       xsp = jj_scanpos;
34603       if (jj_3R_261()) { jj_scanpos = xsp; break; }
34604     }
34605     return false;
34606   }
34607 
34608   private boolean jj_3R_167() {
34609     if (jj_3R_260()) return true;
34610     return false;
34611   }
34612 
34613   private boolean jj_3R_377() {
34614     if (jj_3R_234()) return true;
34615     if (jj_scan_token(4)) return true;
34616     return false;
34617   }
34618 
34619   private boolean jj_3R_310() {
34620     if (jj_3R_147()) return true;
34621     return false;
34622   }
34623 
34624   private boolean jj_3R_311() {
34625     if (jj_3R_352()) return true;
34626     return false;
34627   }
34628 
34629   private boolean jj_3R_376() {
34630     if (jj_3R_422()) return true;
34631     if (jj_scan_token(4)) return true;
34632     return false;
34633   }
34634 
34635   private boolean jj_3R_375() {
34636     if (jj_3R_421()) return true;
34637     return false;
34638   }
34639 
34640   private boolean jj_3R_374() {
34641     if (jj_3R_420()) return true;
34642     if (jj_scan_token(4)) return true;
34643     return false;
34644   }
34645 
34646   private boolean jj_3R_443() {
34647     if (jj_scan_token(LOCK)) return true;
34648     if (jj_scan_token(TABLE)) return true;
34649     return false;
34650   }
34651 
34652   private boolean jj_3R_373() {
34653     if (jj_3R_419()) return true;
34654     if (jj_scan_token(4)) return true;
34655     return false;
34656   }
34657 
34658   private boolean jj_3R_372() {
34659     if (jj_3R_272()) return true;
34660     if (jj_scan_token(4)) return true;
34661     return false;
34662   }
34663 
34664   private boolean jj_3R_371() {
34665     if (jj_3R_418()) return true;
34666     if (jj_scan_token(4)) return true;
34667     return false;
34668   }
34669 
34670   private boolean jj_3R_370() {
34671     if (jj_3R_417()) return true;
34672     if (jj_scan_token(4)) return true;
34673     return false;
34674   }
34675 
34676   private boolean jj_3R_166() {
34677     Token xsp;
34678     xsp = jj_scanpos;
34679     if (jj_scan_token(183)) jj_scanpos = xsp;
34680     xsp = jj_scanpos;
34681     if (jj_scan_token(119)) {
34682     jj_scanpos = xsp;
34683     if (jj_scan_token(145)) {
34684     jj_scanpos = xsp;
34685     if (jj_scan_token(185)) return true;
34686     }
34687     }
34688     return false;
34689   }
34690 
34691   private boolean jj_3R_259() {
34692     if (jj_scan_token(6)) return true;
34693     Token xsp;
34694     xsp = jj_scanpos;
34695     if (jj_3R_310()) {
34696     jj_scanpos = xsp;
34697     if (jj_3_70()) {
34698     jj_scanpos = xsp;
34699     if (jj_3R_311()) return true;
34700     }
34701     }
34702     return false;
34703   }
34704 
34705   private boolean jj_3R_369() {
34706     if (jj_3R_416()) return true;
34707     if (jj_scan_token(4)) return true;
34708     return false;
34709   }
34710 
34711   private boolean jj_3R_309() {
34712     if (jj_3R_352()) return true;
34713     return false;
34714   }
34715 
34716   private boolean jj_3R_368() {
34717     if (jj_3R_415()) return true;
34718     if (jj_scan_token(4)) return true;
34719     return false;
34720   }
34721 
34722   private boolean jj_3R_367() {
34723     if (jj_3R_414()) return true;
34724     if (jj_scan_token(4)) return true;
34725     return false;
34726   }
34727 
34728   private boolean jj_3R_366() {
34729     if (jj_3R_413()) return true;
34730     if (jj_scan_token(4)) return true;
34731     return false;
34732   }
34733 
34734   private boolean jj_3_69() {
34735     if (jj_3R_147()) return true;
34736     return false;
34737   }
34738 
34739   private boolean jj_3R_258() {
34740     Token xsp;
34741     xsp = jj_scanpos;
34742     if (jj_3_69()) {
34743     jj_scanpos = xsp;
34744     if (jj_3R_308()) {
34745     jj_scanpos = xsp;
34746     if (jj_3R_309()) return true;
34747     }
34748     }
34749     return false;
34750   }
34751 
34752   private boolean jj_3R_365() {
34753     if (jj_3R_412()) return true;
34754     if (jj_scan_token(4)) return true;
34755     return false;
34756   }
34757 
34758   private boolean jj_3_42() {
34759     Token xsp;
34760     xsp = jj_scanpos;
34761     if (jj_3R_129()) {
34762     jj_scanpos = xsp;
34763     if (jj_scan_token(297)) {
34764     jj_scanpos = xsp;
34765     if (jj_scan_token(144)) {
34766     jj_scanpos = xsp;
34767     if (jj_scan_token(93)) {
34768     jj_scanpos = xsp;
34769     if (jj_scan_token(76)) {
34770     jj_scanpos = xsp;
34771     if (jj_scan_token(241)) {
34772     jj_scanpos = xsp;
34773     if (jj_scan_token(248)) {
34774     jj_scanpos = xsp;
34775     if (jj_scan_token(111)) {
34776     jj_scanpos = xsp;
34777     if (jj_3R_130()) {
34778     jj_scanpos = xsp;
34779     if (jj_3R_131()) {
34780     jj_scanpos = xsp;
34781     if (jj_scan_token(165)) {
34782     jj_scanpos = xsp;
34783     if (jj_scan_token(318)) return true;
34784     }
34785     }
34786     }
34787     }
34788     }
34789     }
34790     }
34791     }
34792     }
34793     }
34794     }
34795     return false;
34796   }
34797 
34798   private boolean jj_3R_129() {
34799     Token xsp;
34800     xsp = jj_scanpos;
34801     if (jj_scan_token(5)) jj_scanpos = xsp;
34802     if (jj_scan_token(SELECT)) return true;
34803     return false;
34804   }
34805 
34806   private boolean jj_3R_364() {
34807     if (jj_3R_411()) return true;
34808     if (jj_scan_token(4)) return true;
34809     return false;
34810   }
34811 
34812   private boolean jj_3R_363() {
34813     if (jj_3R_410()) return true;
34814     if (jj_scan_token(4)) return true;
34815     return false;
34816   }
34817 
34818   private boolean jj_3R_165() {
34819     if (jj_scan_token(5)) return true;
34820     Token xsp;
34821     while (true) {
34822       xsp = jj_scanpos;
34823       if (jj_3R_258()) { jj_scanpos = xsp; break; }
34824     }
34825     while (true) {
34826       xsp = jj_scanpos;
34827       if (jj_3R_259()) { jj_scanpos = xsp; break; }
34828     }
34829     if (jj_scan_token(7)) return true;
34830     return false;
34831   }
34832 
34833   private boolean jj_3R_362() {
34834     if (jj_3R_409()) return true;
34835     if (jj_scan_token(4)) return true;
34836     return false;
34837   }
34838 
34839   private boolean jj_3R_361() {
34840     if (jj_3R_408()) return true;
34841     if (jj_scan_token(4)) return true;
34842     return false;
34843   }
34844 
34845   private boolean jj_3R_360() {
34846     if (jj_3R_407()) return true;
34847     if (jj_scan_token(4)) return true;
34848     return false;
34849   }
34850 
34851   private boolean jj_3R_359() {
34852     if (jj_3R_406()) return true;
34853     if (jj_scan_token(4)) return true;
34854     return false;
34855   }
34856 
34857   private boolean jj_3_43() {
34858     if (jj_3R_132()) return true;
34859     if (jj_scan_token(4)) return true;
34860     return false;
34861   }
34862 
34863   private boolean jj_3R_358() {
34864     if (jj_3R_405()) return true;
34865     Token xsp;
34866     xsp = jj_scanpos;
34867     if (jj_scan_token(4)) jj_scanpos = xsp;
34868     return false;
34869   }
34870 
34871   private boolean jj_3R_442() {
34872     if (jj_scan_token(SET)) return true;
34873     if (jj_scan_token(TRANSACTION)) return true;
34874     return false;
34875   }
34876 
34877   private boolean jj_3R_604() {
34878     if (jj_3R_124()) return true;
34879     return false;
34880   }
34881 
34882   private boolean jj_3R_317() {
34883     Token xsp;
34884     xsp = jj_scanpos;
34885     if (jj_3R_358()) {
34886     jj_scanpos = xsp;
34887     if (jj_3_43()) {
34888     jj_scanpos = xsp;
34889     if (jj_3R_359()) {
34890     jj_scanpos = xsp;
34891     if (jj_3R_360()) {
34892     jj_scanpos = xsp;
34893     if (jj_3R_361()) {
34894     jj_scanpos = xsp;
34895     if (jj_3R_362()) {
34896     jj_scanpos = xsp;
34897     if (jj_3R_363()) {
34898     jj_scanpos = xsp;
34899     if (jj_3R_364()) {
34900     jj_scanpos = xsp;
34901     if (jj_3R_365()) {
34902     jj_scanpos = xsp;
34903     if (jj_3R_366()) {
34904     jj_scanpos = xsp;
34905     if (jj_3R_367()) {
34906     jj_scanpos = xsp;
34907     if (jj_3R_368()) {
34908     jj_scanpos = xsp;
34909     if (jj_3R_369()) {
34910     jj_scanpos = xsp;
34911     if (jj_3R_370()) {
34912     jj_scanpos = xsp;
34913     if (jj_3R_371()) {
34914     jj_scanpos = xsp;
34915     if (jj_3R_372()) {
34916     jj_scanpos = xsp;
34917     if (jj_3R_373()) {
34918     jj_scanpos = xsp;
34919     if (jj_3R_374()) {
34920     jj_scanpos = xsp;
34921     if (jj_3R_375()) {
34922     jj_scanpos = xsp;
34923     if (jj_3R_376()) {
34924     jj_scanpos = xsp;
34925     if (jj_3R_377()) return true;
34926     }
34927     }
34928     }
34929     }
34930     }
34931     }
34932     }
34933     }
34934     }
34935     }
34936     }
34937     }
34938     }
34939     }
34940     }
34941     }
34942     }
34943     }
34944     }
34945     }
34946     return false;
34947   }
34948 
34949   private boolean jj_3R_164() {
34950     if (jj_3R_249()) return true;
34951     return false;
34952   }
34953 
34954   private boolean jj_3_67() {
34955     Token xsp;
34956     xsp = jj_scanpos;
34957     if (jj_scan_token(152)) {
34958     jj_scanpos = xsp;
34959     if (jj_scan_token(51)) return true;
34960     }
34961     if (jj_3R_146()) return true;
34962     if (jj_scan_token(OF)) return true;
34963     if (jj_3R_236()) return true;
34964     return false;
34965   }
34966 
34967   private boolean jj_3R_145() {
34968     if (jj_3R_239()) return true;
34969     return false;
34970   }
34971 
34972   private boolean jj_3_66() {
34973     Token xsp;
34974     xsp = jj_scanpos;
34975     if (jj_scan_token(152)) {
34976     jj_scanpos = xsp;
34977     if (jj_scan_token(51)) return true;
34978     }
34979     if (jj_scan_token(OPAQUE)) return true;
34980     if (jj_scan_token(VARYING)) return true;
34981     if (jj_scan_token(24)) return true;
34982     return false;
34983   }
34984 
34985   private boolean jj_3_68() {
34986     if (jj_scan_token(EXTERNAL)) return true;
34987     if (jj_scan_token(IDENTIFIER)) return true;
34988     if (jj_scan_token(IDENTIFIER)) return true;
34989     if (jj_scan_token(LANGUAGE)) return true;
34990     if (jj_scan_token(JAVA)) return true;
34991     if (jj_scan_token(USING)) return true;
34992     if (jj_scan_token(IDENTIFIER)) return true;
34993     return false;
34994   }
34995 
34996   private boolean jj_3_65() {
34997     Token xsp;
34998     xsp = jj_scanpos;
34999     if (jj_scan_token(152)) {
35000     jj_scanpos = xsp;
35001     if (jj_scan_token(51)) return true;
35002     }
35003     if (jj_scan_token(OBJECT)) return true;
35004     return false;
35005   }
35006 
35007   private boolean jj_3R_144() {
35008     if (jj_scan_token(AUTHID)) return true;
35009     Token xsp;
35010     xsp = jj_scanpos;
35011     if (jj_scan_token(37)) {
35012     jj_scanpos = xsp;
35013     if (jj_scan_token(36)) return true;
35014     }
35015     return false;
35016   }
35017 
35018   private boolean jj_3R_257() {
35019     if (jj_scan_token(UNDER)) return true;
35020     if (jj_3R_155()) return true;
35021     return false;
35022   }
35023 
35024   private boolean jj_3R_163() {
35025     Token xsp;
35026     xsp = jj_scanpos;
35027     if (jj_3R_257()) {
35028     jj_scanpos = xsp;
35029     if (jj_3_65()) {
35030     jj_scanpos = xsp;
35031     if (jj_3_66()) {
35032     jj_scanpos = xsp;
35033     if (jj_3_67()) return true;
35034     }
35035     }
35036     }
35037     return false;
35038   }
35039 
35040   private boolean jj_3R_256() {
35041     Token xsp;
35042     xsp = jj_scanpos;
35043     if (jj_scan_token(100)) {
35044     jj_scanpos = xsp;
35045     if (jj_scan_token(182)) return true;
35046     }
35047     return false;
35048   }
35049 
35050   private boolean jj_3R_249() {
35051     if (jj_scan_token(WRAPPED)) return true;
35052     return false;
35053   }
35054 
35055   private boolean jj_3R_603() {
35056     if (jj_3R_351()) return true;
35057     return false;
35058   }
35059 
35060   private boolean jj_3_64() {
35061     Token xsp;
35062     xsp = jj_scanpos;
35063     if (jj_3R_144()) {
35064     jj_scanpos = xsp;
35065     if (jj_3R_145()) return true;
35066     }
35067     return false;
35068   }
35069 
35070   private boolean jj_3_63() {
35071     if (jj_scan_token(OID)) return true;
35072     if (jj_scan_token(STRING_LITERAL)) return true;
35073     return false;
35074   }
35075 
35076   private boolean jj_3R_255() {
35077     if (jj_scan_token(OR)) return true;
35078     if (jj_scan_token(REPLACE)) return true;
35079     return false;
35080   }
35081 
35082   private boolean jj_3R_602() {
35083     if (jj_3R_174()) return true;
35084     return false;
35085   }
35086 
35087   private boolean jj_3R_162() {
35088     if (jj_scan_token(CREATE)) return true;
35089     Token xsp;
35090     xsp = jj_scanpos;
35091     if (jj_3R_255()) jj_scanpos = xsp;
35092     xsp = jj_scanpos;
35093     if (jj_3R_256()) jj_scanpos = xsp;
35094     return false;
35095   }
35096 
35097   private boolean jj_3R_105() {
35098     Token xsp;
35099     xsp = jj_scanpos;
35100     if (jj_3R_162()) jj_scanpos = xsp;
35101     if (jj_scan_token(TYPE)) return true;
35102     if (jj_3R_155()) return true;
35103     xsp = jj_scanpos;
35104     if (jj_scan_token(123)) jj_scanpos = xsp;
35105     xsp = jj_scanpos;
35106     if (jj_3_63()) jj_scanpos = xsp;
35107     while (true) {
35108       xsp = jj_scanpos;
35109       if (jj_3_64()) { jj_scanpos = xsp; break; }
35110     }
35111     xsp = jj_scanpos;
35112     if (jj_3R_163()) jj_scanpos = xsp;
35113     xsp = jj_scanpos;
35114     if (jj_3_68()) jj_scanpos = xsp;
35115     xsp = jj_scanpos;
35116     if (jj_3R_164()) jj_scanpos = xsp;
35117     xsp = jj_scanpos;
35118     if (jj_3R_165()) jj_scanpos = xsp;
35119     while (true) {
35120       xsp = jj_scanpos;
35121       if (jj_3R_166()) { jj_scanpos = xsp; break; }
35122     }
35123     while (true) {
35124       xsp = jj_scanpos;
35125       if (jj_3R_167()) { jj_scanpos = xsp; break; }
35126     }
35127     xsp = jj_scanpos;
35128     if (jj_3R_168()) jj_scanpos = xsp;
35129     return false;
35130   }
35131 
35132   private boolean jj_3R_568() {
35133     if (jj_3R_192()) return true;
35134     if (jj_scan_token(BEGIN)) return true;
35135     Token xsp;
35136     while (true) {
35137       xsp = jj_scanpos;
35138       if (jj_3R_602()) { jj_scanpos = xsp; break; }
35139     }
35140     xsp = jj_scanpos;
35141     if (jj_3R_603()) jj_scanpos = xsp;
35142     if (jj_scan_token(END)) return true;
35143     xsp = jj_scanpos;
35144     if (jj_3R_604()) jj_scanpos = xsp;
35145     if (jj_scan_token(4)) return true;
35146     return false;
35147   }
35148 
35149   private boolean jj_3R_567() {
35150     if (jj_3R_123()) return true;
35151     Token xsp;
35152     xsp = jj_scanpos;
35153     if (jj_scan_token(4)) jj_scanpos = xsp;
35154     return false;
35155   }
35156 
35157   private boolean jj_3R_531() {
35158     Token xsp;
35159     xsp = jj_scanpos;
35160     if (jj_scan_token(152)) {
35161     jj_scanpos = xsp;
35162     if (jj_scan_token(51)) return true;
35163     }
35164     xsp = jj_scanpos;
35165     if (jj_3R_567()) {
35166     jj_scanpos = xsp;
35167     if (jj_3R_568()) return true;
35168     }
35169     return false;
35170   }
35171 
35172   private boolean jj_3R_405() {
35173     Token xsp;
35174     xsp = jj_scanpos;
35175     if (jj_scan_token(250)) {
35176     jj_scanpos = xsp;
35177     if (jj_scan_token(297)) {
35178     jj_scanpos = xsp;
35179     if (jj_scan_token(144)) {
35180     jj_scanpos = xsp;
35181     if (jj_scan_token(93)) {
35182     jj_scanpos = xsp;
35183     if (jj_scan_token(76)) {
35184     jj_scanpos = xsp;
35185     if (jj_scan_token(241)) {
35186     jj_scanpos = xsp;
35187     if (jj_scan_token(248)) {
35188     jj_scanpos = xsp;
35189     if (jj_scan_token(111)) {
35190     jj_scanpos = xsp;
35191     if (jj_3R_442()) {
35192     jj_scanpos = xsp;
35193     if (jj_3R_443()) {
35194     jj_scanpos = xsp;
35195     if (jj_scan_token(165)) {
35196     jj_scanpos = xsp;
35197     if (jj_scan_token(318)) return true;
35198     }
35199     }
35200     }
35201     }
35202     }
35203     }
35204     }
35205     }
35206     }
35207     }
35208     }
35209     if (jj_3R_180()) return true;
35210     return false;
35211   }
35212 
35213   private boolean jj_3_61() {
35214     if (jj_3R_124()) return true;
35215     if (jj_scan_token(3)) return true;
35216     return false;
35217   }
35218 
35219   private boolean jj_3R_491() {
35220     return false;
35221   }
35222 
35223   private boolean jj_3R_242() {
35224     Token xsp;
35225     xsp = jj_scanpos;
35226     if (jj_scan_token(162)) {
35227     jj_scanpos = xsp;
35228     if (jj_scan_token(204)) return true;
35229     }
35230     return false;
35231   }
35232 
35233   private boolean jj_3R_241() {
35234     Token xsp;
35235     xsp = jj_scanpos;
35236     if (jj_scan_token(183)) jj_scanpos = xsp;
35237     xsp = jj_scanpos;
35238     if (jj_scan_token(208)) {
35239     jj_scanpos = xsp;
35240     if (jj_scan_token(145)) {
35241     jj_scanpos = xsp;
35242     if (jj_scan_token(119)) return true;
35243     }
35244     }
35245     return false;
35246   }
35247 
35248   private boolean jj_3_62() {
35249     if (jj_3R_124()) return true;
35250     if (jj_scan_token(3)) return true;
35251     if (jj_3R_124()) return true;
35252     if (jj_scan_token(3)) return true;
35253     if (jj_3R_124()) return true;
35254     return false;
35255   }
35256 
35257   private boolean jj_3R_147() {
35258     Token xsp;
35259     while (true) {
35260       xsp = jj_scanpos;
35261       if (jj_3R_241()) { jj_scanpos = xsp; break; }
35262     }
35263     xsp = jj_scanpos;
35264     if (jj_3R_242()) jj_scanpos = xsp;
35265     xsp = jj_scanpos;
35266     if (jj_scan_token(80)) {
35267     jj_scanpos = xsp;
35268     if (jj_scan_token(164)) {
35269     jj_scanpos = xsp;
35270     if (jj_scan_token(262)) return true;
35271     }
35272     }
35273     if (jj_3R_194()) return true;
35274     xsp = jj_scanpos;
35275     if (jj_scan_token(95)) jj_scanpos = xsp;
35276     xsp = jj_scanpos;
35277     if (jj_scan_token(210)) jj_scanpos = xsp;
35278     xsp = jj_scanpos;
35279     if (jj_scan_token(214)) jj_scanpos = xsp;
35280     xsp = jj_scanpos;
35281     if (jj_scan_token(236)) jj_scanpos = xsp;
35282     xsp = jj_scanpos;
35283     if (jj_3R_531()) jj_scanpos = xsp;
35284     return false;
35285   }
35286 
35287   private boolean jj_3R_188() {
35288     return false;
35289   }
35290 
35291   private boolean jj_3R_262() {
35292     if (jj_3R_124()) return true;
35293     return false;
35294   }
35295 
35296   private boolean jj_3R_190() {
35297     return false;
35298   }
35299 
35300   private boolean jj_3R_185() {
35301     if (jj_3R_143()) return true;
35302     if (jj_scan_token(IDENTIFIED)) return true;
35303     return false;
35304   }
35305 
35306   private boolean jj_3R_184() {
35307     if (jj_scan_token(CONNECT)) return true;
35308     if (jj_scan_token(TO)) return true;
35309     return false;
35310   }
35311 
35312   private boolean jj_3R_112() {
35313     if (jj_scan_token(CREATE)) return true;
35314     Token xsp;
35315     xsp = jj_scanpos;
35316     if (jj_scan_token(410)) jj_scanpos = xsp;
35317     xsp = jj_scanpos;
35318     if (jj_scan_token(224)) jj_scanpos = xsp;
35319     if (jj_scan_token(DATABASE)) return true;
35320     if (jj_scan_token(LINK)) return true;
35321     if (jj_3R_155()) return true;
35322     xsp = jj_scanpos;
35323     if (jj_3R_184()) {
35324     jj_scanpos = xsp;
35325     if (jj_3R_185()) return true;
35326     }
35327     return false;
35328   }
35329 
35330   private boolean jj_3R_459() {
35331     if (jj_3R_174()) return true;
35332     return false;
35333   }
35334 
35335   private boolean jj_3R_182() {
35336     if (jj_scan_token(OR)) return true;
35337     if (jj_scan_token(REPLACE)) return true;
35338     return false;
35339   }
35340 
35341   private boolean jj_3R_111() {
35342     if (jj_scan_token(CREATE)) return true;
35343     Token xsp;
35344     xsp = jj_scanpos;
35345     if (jj_3R_182()) jj_scanpos = xsp;
35346     if (jj_scan_token(DIRECTORY)) return true;
35347     if (jj_3R_155()) return true;
35348     if (jj_scan_token(AS)) return true;
35349     if (jj_3R_183()) return true;
35350     xsp = jj_scanpos;
35351     if (jj_scan_token(4)) {
35352     jj_scanpos = xsp;
35353     if (jj_scan_token(1)) return true;
35354     }
35355     return false;
35356   }
35357 
35358   private boolean jj_3R_181() {
35359     if (jj_scan_token(OR)) return true;
35360     if (jj_scan_token(REPLACE)) return true;
35361     return false;
35362   }
35363 
35364   private boolean jj_3R_564() {
35365     return false;
35366   }
35367 
35368   private boolean jj_3R_263() {
35369     if (jj_scan_token(6)) return true;
35370     return false;
35371   }
35372 
35373   private boolean jj_3R_110() {
35374     if (jj_scan_token(CREATE)) return true;
35375     Token xsp;
35376     xsp = jj_scanpos;
35377     if (jj_3R_181()) jj_scanpos = xsp;
35378     xsp = jj_scanpos;
35379     if (jj_scan_token(224)) jj_scanpos = xsp;
35380     if (jj_scan_token(SYNONYM)) return true;
35381     if (jj_3R_155()) return true;
35382     if (jj_scan_token(FOR)) return true;
35383     if (jj_3R_155()) return true;
35384     xsp = jj_scanpos;
35385     if (jj_scan_token(4)) {
35386     jj_scanpos = xsp;
35387     if (jj_scan_token(1)) return true;
35388     }
35389     return false;
35390   }
35391 
35392   private boolean jj_3R_458() {
35393     if (jj_scan_token(OR)) return true;
35394     if (jj_3R_128()) return true;
35395     return false;
35396   }
35397 
35398   private boolean jj_3R_171() {
35399     if (jj_scan_token(OR)) return true;
35400     if (jj_scan_token(REPLACE)) return true;
35401     return false;
35402   }
35403 
35404   private boolean jj_3R_173() {
35405     if (jj_scan_token(5)) return true;
35406     if (jj_3R_262()) return true;
35407     Token xsp;
35408     while (true) {
35409       xsp = jj_scanpos;
35410       if (jj_3R_263()) { jj_scanpos = xsp; break; }
35411     }
35412     if (jj_scan_token(7)) return true;
35413     return false;
35414   }
35415 
35416   private boolean jj_3R_460() {
35417     if (jj_3R_174()) return true;
35418     return false;
35419   }
35420 
35421   private boolean jj_3R_172() {
35422     Token xsp;
35423     xsp = jj_scanpos;
35424     if (jj_scan_token(179)) jj_scanpos = xsp;
35425     if (jj_scan_token(FORCE)) return true;
35426     return false;
35427   }
35428 
35429   private boolean jj_3R_107() {
35430     if (jj_scan_token(CREATE)) return true;
35431     Token xsp;
35432     xsp = jj_scanpos;
35433     if (jj_3R_171()) jj_scanpos = xsp;
35434     xsp = jj_scanpos;
35435     if (jj_3R_172()) jj_scanpos = xsp;
35436     if (jj_scan_token(VIEW)) return true;
35437     if (jj_3R_155()) return true;
35438     xsp = jj_scanpos;
35439     if (jj_3R_173()) jj_scanpos = xsp;
35440     if (jj_scan_token(AS)) return true;
35441     if (jj_3R_174()) return true;
35442     xsp = jj_scanpos;
35443     if (jj_scan_token(4)) {
35444     jj_scanpos = xsp;
35445     if (jj_scan_token(1)) return true;
35446     }
35447     return false;
35448   }
35449 
35450   private boolean jj_3R_180() {
35451     return false;
35452   }
35453 
35454   private boolean jj_3R_170() {
35455     if (jj_3R_124()) return true;
35456     if (jj_3R_236()) return true;
35457     return false;
35458   }
35459 
35460   private boolean jj_3R_629() {
35461     if (jj_scan_token(6)) return true;
35462     if (jj_3R_124()) return true;
35463     return false;
35464   }
35465 
35466   private boolean jj_3R_628() {
35467     if (jj_scan_token(6)) return true;
35468     if (jj_3R_124()) return true;
35469     return false;
35470   }
35471 
35472   private boolean jj_3R_169() {
35473     if (jj_scan_token(GLOBAL)) return true;
35474     if (jj_scan_token(TEMPORARY)) return true;
35475     return false;
35476   }
35477 
35478   private boolean jj_3R_401() {
35479     if (jj_scan_token(WHEN)) return true;
35480     if (jj_scan_token(OTHERS)) return true;
35481     if (jj_scan_token(THEN)) return true;
35482     Token xsp;
35483     if (jj_3R_460()) return true;
35484     while (true) {
35485       xsp = jj_scanpos;
35486       if (jj_3R_460()) { jj_scanpos = xsp; break; }
35487     }
35488     return false;
35489   }
35490 
35491   private boolean jj_3_41() {
35492     if (jj_scan_token(WHEN)) return true;
35493     if (jj_3R_128()) return true;
35494     Token xsp;
35495     while (true) {
35496       xsp = jj_scanpos;
35497       if (jj_3R_458()) { jj_scanpos = xsp; break; }
35498     }
35499     if (jj_scan_token(THEN)) return true;
35500     if (jj_3R_459()) return true;
35501     while (true) {
35502       xsp = jj_scanpos;
35503       if (jj_3R_459()) { jj_scanpos = xsp; break; }
35504     }
35505     return false;
35506   }
35507 
35508   private boolean jj_3_60() {
35509     if (jj_scan_token(ON)) return true;
35510     if (jj_scan_token(COMMIT)) return true;
35511     return false;
35512   }
35513 
35514   private boolean jj_3R_106() {
35515     if (jj_scan_token(CREATE)) return true;
35516     Token xsp;
35517     xsp = jj_scanpos;
35518     if (jj_3R_169()) jj_scanpos = xsp;
35519     if (jj_scan_token(TABLE)) return true;
35520     if (jj_3R_155()) return true;
35521     if (jj_scan_token(5)) return true;
35522     if (jj_3R_170()) return true;
35523     return false;
35524   }
35525 
35526   private boolean jj_3R_351() {
35527     if (jj_scan_token(EXCEPTION)) return true;
35528     Token xsp;
35529     while (true) {
35530       xsp = jj_scanpos;
35531       if (jj_3_41()) { jj_scanpos = xsp; break; }
35532     }
35533     xsp = jj_scanpos;
35534     if (jj_3R_401()) jj_scanpos = xsp;
35535     return false;
35536   }
35537 
35538   private boolean jj_3R_621() {
35539     Token xsp;
35540     xsp = jj_scanpos;
35541     if (jj_scan_token(125)) {
35542     jj_scanpos = xsp;
35543     if (jj_scan_token(223)) {
35544     jj_scanpos = xsp;
35545     if (jj_scan_token(209)) {
35546     jj_scanpos = xsp;
35547     if (jj_scan_token(282)) {
35548     jj_scanpos = xsp;
35549     if (jj_scan_token(284)) return true;
35550     }
35551     }
35552     }
35553     }
35554     return false;
35555   }
35556 
35557   private boolean jj_3R_349() {
35558     Token xsp;
35559     xsp = jj_scanpos;
35560     if (jj_scan_token(125)) {
35561     jj_scanpos = xsp;
35562     if (jj_scan_token(223)) {
35563     jj_scanpos = xsp;
35564     if (jj_scan_token(209)) {
35565     jj_scanpos = xsp;
35566     if (jj_scan_token(282)) {
35567     jj_scanpos = xsp;
35568     if (jj_scan_token(284)) return true;
35569     }
35570     }
35571     }
35572     }
35573     return false;
35574   }
35575 
35576   private boolean jj_3R_350() {
35577     if (jj_scan_token(6)) return true;
35578     Token xsp;
35579     xsp = jj_scanpos;
35580     if (jj_3R_621()) jj_scanpos = xsp;
35581     if (jj_3R_128()) return true;
35582     return false;
35583   }
35584 
35585   private boolean jj_3R_490() {
35586     if (jj_scan_token(6)) return true;
35587     if (jj_3R_127()) return true;
35588     return false;
35589   }
35590 
35591   private boolean jj_3R_489() {
35592     Token xsp;
35593     xsp = jj_scanpos;
35594     if (jj_scan_token(16)) {
35595     jj_scanpos = xsp;
35596     if (jj_scan_token(17)) return true;
35597     }
35598     return false;
35599   }
35600 
35601   private boolean jj_3_40() {
35602     if (jj_scan_token(5)) return true;
35603     if (jj_3R_127()) return true;
35604     if (jj_scan_token(7)) return true;
35605     return false;
35606   }
35607 
35608   private boolean jj_3R_239() {
35609     if (jj_scan_token(ACCESSIBLE)) return true;
35610     if (jj_scan_token(BY)) return true;
35611     if (jj_scan_token(5)) return true;
35612     Token xsp;
35613     xsp = jj_scanpos;
35614     if (jj_3R_349()) jj_scanpos = xsp;
35615     if (jj_3R_128()) return true;
35616     while (true) {
35617       xsp = jj_scanpos;
35618       if (jj_3R_350()) { jj_scanpos = xsp; break; }
35619     }
35620     if (jj_scan_token(7)) return true;
35621     return false;
35622   }
35623 
35624   private boolean jj_3R_622() {
35625     Token xsp;
35626     xsp = jj_scanpos;
35627     if (jj_scan_token(130)) {
35628     jj_scanpos = xsp;
35629     if (jj_scan_token(226)) return true;
35630     }
35631     if (jj_scan_token(5)) return true;
35632     if (jj_3R_124()) return true;
35633     while (true) {
35634       xsp = jj_scanpos;
35635       if (jj_3R_628()) { jj_scanpos = xsp; break; }
35636     }
35637     if (jj_scan_token(7)) return true;
35638     return false;
35639   }
35640 
35641   private boolean jj_3R_623() {
35642     Token xsp;
35643     xsp = jj_scanpos;
35644     if (jj_scan_token(204)) {
35645     jj_scanpos = xsp;
35646     if (jj_scan_token(71)) return true;
35647     }
35648     if (jj_scan_token(BY)) return true;
35649     if (jj_scan_token(5)) return true;
35650     if (jj_3R_124()) return true;
35651     while (true) {
35652       xsp = jj_scanpos;
35653       if (jj_3R_629()) { jj_scanpos = xsp; break; }
35654     }
35655     if (jj_scan_token(7)) return true;
35656     return false;
35657   }
35658 
35659   private boolean jj_3R_481() {
35660     if (jj_scan_token(TO)) return true;
35661     Token xsp;
35662     xsp = jj_scanpos;
35663     if (jj_scan_token(316)) {
35664     jj_scanpos = xsp;
35665     if (jj_scan_token(173)) {
35666     jj_scanpos = xsp;
35667     if (jj_scan_token(89)) {
35668     jj_scanpos = xsp;
35669     if (jj_scan_token(133)) {
35670     jj_scanpos = xsp;
35671     if (jj_scan_token(168)) {
35672     jj_scanpos = xsp;
35673     if (jj_scan_token(249)) return true;
35674     }
35675     }
35676     }
35677     }
35678     }
35679     xsp = jj_scanpos;
35680     if (jj_3_40()) jj_scanpos = xsp;
35681     return false;
35682   }
35683 
35684   private boolean jj_3R_507() {
35685     if (jj_scan_token(LOCAL)) return true;
35686     return false;
35687   }
35688 
35689   private boolean jj_3R_480() {
35690     if (jj_scan_token(WITH)) return true;
35691     Token xsp;
35692     xsp = jj_scanpos;
35693     if (jj_3R_507()) jj_scanpos = xsp;
35694     if (jj_scan_token(TIME)) return true;
35695     if (jj_scan_token(ZONE)) return true;
35696     return false;
35697   }
35698 
35699   private boolean jj_3R_435() {
35700     Token xsp;
35701     xsp = jj_scanpos;
35702     if (jj_3R_480()) {
35703     jj_scanpos = xsp;
35704     if (jj_3R_481()) return true;
35705     }
35706     return false;
35707   }
35708 
35709   private boolean jj_3R_429() {
35710     if (jj_scan_token(5)) return true;
35711     if (jj_scan_token(PARTITION)) return true;
35712     if (jj_3R_124()) return true;
35713     if (jj_scan_token(BY)) return true;
35714     Token xsp;
35715     xsp = jj_scanpos;
35716     if (jj_scan_token(49)) {
35717     jj_scanpos = xsp;
35718     if (jj_3R_622()) return true;
35719     }
35720     if (jj_scan_token(7)) return true;
35721     xsp = jj_scanpos;
35722     if (jj_3R_623()) jj_scanpos = xsp;
35723     return false;
35724   }
35725 
35726   private boolean jj_3_39() {
35727     if (jj_scan_token(5)) return true;
35728     if (jj_3R_127()) return true;
35729     if (jj_scan_token(7)) return true;
35730     return false;
35731   }
35732 
35733   private boolean jj_3R_119() {
35734     if (jj_3R_124()) return true;
35735     if (jj_scan_token(EXCEPTION)) return true;
35736     if (jj_scan_token(4)) return true;
35737     return false;
35738   }
35739 
35740   private boolean jj_3R_519() {
35741     if (jj_3R_183()) return true;
35742     return false;
35743   }
35744 
35745   private boolean jj_3R_422() {
35746     if (jj_scan_token(PRAGMA)) return true;
35747     if (jj_scan_token(INLINE)) return true;
35748     if (jj_scan_token(5)) return true;
35749     if (jj_3R_128()) return true;
35750     if (jj_scan_token(6)) return true;
35751     if (jj_3R_183()) return true;
35752     if (jj_scan_token(7)) return true;
35753     return false;
35754   }
35755 
35756   private boolean jj_3R_518() {
35757     if (jj_3R_124()) return true;
35758     return false;
35759   }
35760 
35761   private boolean jj_3R_469() {
35762     if (jj_3R_128()) return true;
35763     if (jj_scan_token(5)) return true;
35764     if (jj_3R_491()) return true;
35765     return false;
35766   }
35767 
35768   private boolean jj_3R_434() {
35769     Token xsp;
35770     xsp = jj_scanpos;
35771     if (jj_scan_token(316)) {
35772     jj_scanpos = xsp;
35773     if (jj_scan_token(173)) {
35774     jj_scanpos = xsp;
35775     if (jj_scan_token(89)) {
35776     jj_scanpos = xsp;
35777     if (jj_scan_token(133)) {
35778     jj_scanpos = xsp;
35779     if (jj_scan_token(168)) {
35780     jj_scanpos = xsp;
35781     if (jj_scan_token(249)) return true;
35782     }
35783     }
35784     }
35785     }
35786     }
35787     return false;
35788   }
35789 
35790   private boolean jj_3R_468() {
35791     if (jj_scan_token(INTERFACE)) return true;
35792     if (jj_scan_token(5)) return true;
35793     if (jj_scan_token(IDENTIFIER)) return true;
35794     if (jj_scan_token(6)) return true;
35795     if (jj_3R_124()) return true;
35796     Token xsp;
35797     xsp = jj_scanpos;
35798     if (jj_3R_490()) jj_scanpos = xsp;
35799     if (jj_scan_token(7)) return true;
35800     return false;
35801   }
35802 
35803   private boolean jj_3R_433() {
35804     if (jj_3R_183()) return true;
35805     return false;
35806   }
35807 
35808   private boolean jj_3R_467() {
35809     if (jj_scan_token(EXCEPTION_INIT)) return true;
35810     if (jj_scan_token(5)) return true;
35811     if (jj_scan_token(IDENTIFIER)) return true;
35812     if (jj_scan_token(6)) return true;
35813     Token xsp;
35814     xsp = jj_scanpos;
35815     if (jj_3R_489()) jj_scanpos = xsp;
35816     if (jj_3R_127()) return true;
35817     if (jj_scan_token(7)) return true;
35818     return false;
35819   }
35820 
35821   private boolean jj_3R_488() {
35822     if (jj_scan_token(6)) return true;
35823     Token xsp;
35824     xsp = jj_scanpos;
35825     if (jj_3R_518()) {
35826     jj_scanpos = xsp;
35827     if (jj_3R_519()) return true;
35828     }
35829     return false;
35830   }
35831 
35832   private boolean jj_3R_432() {
35833     if (jj_scan_token(CHARACTER_LITERAL)) return true;
35834     return false;
35835   }
35836 
35837   private boolean jj_3R_466() {
35838     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35839     if (jj_scan_token(5)) return true;
35840     if (jj_3R_124()) return true;
35841     Token xsp;
35842     if (jj_3R_488()) return true;
35843     while (true) {
35844       xsp = jj_scanpos;
35845       if (jj_3R_488()) { jj_scanpos = xsp; break; }
35846     }
35847     if (jj_scan_token(7)) return true;
35848     return false;
35849   }
35850 
35851   private boolean jj_3R_465() {
35852     if (jj_scan_token(TIMESTAMP)) return true;
35853     if (jj_scan_token(5)) return true;
35854     if (jj_3R_183()) return true;
35855     if (jj_scan_token(7)) return true;
35856     return false;
35857   }
35858 
35859   private boolean jj_3R_423() {
35860     if (jj_scan_token(PRAGMA)) return true;
35861     Token xsp;
35862     xsp = jj_scanpos;
35863     if (jj_scan_token(38)) {
35864     jj_scanpos = xsp;
35865     if (jj_scan_token(41)) {
35866     jj_scanpos = xsp;
35867     if (jj_3R_465()) {
35868     jj_scanpos = xsp;
35869     if (jj_3R_466()) {
35870     jj_scanpos = xsp;
35871     if (jj_3R_467()) {
35872     jj_scanpos = xsp;
35873     if (jj_3R_468()) {
35874     jj_scanpos = xsp;
35875     if (jj_3R_469()) return true;
35876     }
35877     }
35878     }
35879     }
35880     }
35881     }
35882     if (jj_scan_token(4)) return true;
35883     return false;
35884   }
35885 
35886   private boolean jj_3_34() {
35887     if (jj_scan_token(5)) return true;
35888     if (jj_3R_127()) return true;
35889     if (jj_scan_token(7)) return true;
35890     return false;
35891   }
35892 
35893   private boolean jj_3R_393() {
35894     Token xsp;
35895     xsp = jj_scanpos;
35896     if (jj_scan_token(149)) {
35897     jj_scanpos = xsp;
35898     if (jj_scan_token(275)) {
35899     jj_scanpos = xsp;
35900     if (jj_scan_token(88)) return true;
35901     }
35902     }
35903     xsp = jj_scanpos;
35904     if (jj_3R_432()) {
35905     jj_scanpos = xsp;
35906     if (jj_3R_433()) return true;
35907     }
35908     xsp = jj_scanpos;
35909     if (jj_3R_434()) jj_scanpos = xsp;
35910     xsp = jj_scanpos;
35911     if (jj_3_39()) jj_scanpos = xsp;
35912     xsp = jj_scanpos;
35913     if (jj_3R_435()) jj_scanpos = xsp;
35914     return false;
35915   }
35916 
35917   private boolean jj_3R_121() {
35918     if (jj_3R_198()) return true;
35919     if (jj_scan_token(4)) return true;
35920     return false;
35921   }
35922 
35923   private boolean jj_3_38() {
35924     if (jj_scan_token(TO)) return true;
35925     if (jj_scan_token(SECOND)) return true;
35926     Token xsp;
35927     xsp = jj_scanpos;
35928     if (jj_3_34()) jj_scanpos = xsp;
35929     return false;
35930   }
35931 
35932   private boolean jj_3_37() {
35933     if (jj_scan_token(TO)) return true;
35934     if (jj_scan_token(MONTH)) return true;
35935     return false;
35936   }
35937 
35938   private boolean jj_3_36() {
35939     if (jj_scan_token(WITH)) return true;
35940     if (jj_scan_token(TIME)) return true;
35941     if (jj_scan_token(ZONE)) return true;
35942     return false;
35943   }
35944 
35945   private boolean jj_3_35() {
35946     if (jj_scan_token(WITH)) return true;
35947     if (jj_scan_token(LOCAL)) return true;
35948     if (jj_scan_token(TIME)) return true;
35949     if (jj_scan_token(ZONE)) return true;
35950     return false;
35951   }
35952 
35953   private boolean jj_3R_569() {
35954     if (jj_scan_token(USING)) return true;
35955     Token xsp;
35956     xsp = jj_scanpos;
35957     if (jj_scan_token(401)) {
35958     jj_scanpos = xsp;
35959     if (jj_scan_token(402)) return true;
35960     }
35961     return false;
35962   }
35963 
35964   private boolean jj_3R_207() {
35965     Token xsp;
35966     xsp = jj_scanpos;
35967     if (jj_3R_291()) {
35968     jj_scanpos = xsp;
35969     if (jj_3_35()) {
35970     jj_scanpos = xsp;
35971     if (jj_3_36()) {
35972     jj_scanpos = xsp;
35973     if (jj_3_37()) {
35974     jj_scanpos = xsp;
35975     if (jj_3_38()) return true;
35976     }
35977     }
35978     }
35979     }
35980     return false;
35981   }
35982 
35983   private boolean jj_3R_291() {
35984     if (jj_scan_token(CHARACTER)) return true;
35985     if (jj_scan_token(SET)) return true;
35986     if (jj_3R_295()) return true;
35987     return false;
35988   }
35989 
35990   private boolean jj_3_59() {
35991     if (jj_3R_143()) return true;
35992     Token xsp;
35993     xsp = jj_scanpos;
35994     if (jj_scan_token(23)) {
35995     jj_scanpos = xsp;
35996     if (jj_scan_token(51)) return true;
35997     }
35998     return false;
35999   }
36000 
36001   private boolean jj_3R_436() {
36002     Token xsp;
36003     xsp = jj_scanpos;
36004     if (jj_3_59()) jj_scanpos = xsp;
36005     if (jj_3R_234()) return true;
36006     xsp = jj_scanpos;
36007     if (jj_3R_569()) jj_scanpos = xsp;
36008     return false;
36009   }
36010 
36011   private boolean jj_3R_441() {
36012     if (jj_scan_token(BYTE)) return true;
36013     return false;
36014   }
36015 
36016   private boolean jj_3R_440() {
36017     if (jj_scan_token(CHAR)) return true;
36018     return false;
36019   }
36020 
36021   private boolean jj_3R_439() {
36022     if (jj_scan_token(6)) return true;
36023     if (jj_3R_484()) return true;
36024     return false;
36025   }
36026 
36027   private boolean jj_3R_536() {
36028     if (jj_scan_token(6)) return true;
36029     if (jj_3R_436()) return true;
36030     return false;
36031   }
36032 
36033   private boolean jj_3_33() {
36034     if (jj_scan_token(5)) return true;
36035     if (jj_3R_127()) return true;
36036     Token xsp;
36037     xsp = jj_scanpos;
36038     if (jj_3R_439()) jj_scanpos = xsp;
36039     xsp = jj_scanpos;
36040     if (jj_3R_440()) jj_scanpos = xsp;
36041     xsp = jj_scanpos;
36042     if (jj_3R_441()) jj_scanpos = xsp;
36043     if (jj_scan_token(7)) return true;
36044     return false;
36045   }
36046 
36047   private boolean jj_3R_394() {
36048     if (jj_3R_436()) return true;
36049     Token xsp;
36050     while (true) {
36051       xsp = jj_scanpos;
36052       if (jj_3R_536()) { jj_scanpos = xsp; break; }
36053     }
36054     return false;
36055   }
36056 
36057   private boolean jj_3R_206() {
36058     if (jj_scan_token(SELF)) return true;
36059     if (jj_scan_token(AS)) return true;
36060     if (jj_scan_token(RESULT)) return true;
36061     return false;
36062   }
36063 
36064   private boolean jj_3R_203() {
36065     if (jj_scan_token(DOUBLE)) return true;
36066     if (jj_scan_token(PRECISION)) return true;
36067     return false;
36068   }
36069 
36070   private boolean jj_3R_342() {
36071     if (jj_3R_394()) return true;
36072     return false;
36073   }
36074 
36075   private boolean jj_3R_142() {
36076     if (jj_scan_token(11)) return true;
36077     return false;
36078   }
36079 
36080   private boolean jj_3R_283() {
36081     Token xsp;
36082     xsp = jj_scanpos;
36083     if (jj_scan_token(117)) {
36084     jj_scanpos = xsp;
36085     if (jj_scan_token(283)) {
36086     jj_scanpos = xsp;
36087     if (jj_scan_token(296)) {
36088     jj_scanpos = xsp;
36089     if (jj_scan_token(377)) {
36090     jj_scanpos = xsp;
36091     if (jj_scan_token(44)) {
36092     jj_scanpos = xsp;
36093     if (jj_scan_token(321)) {
36094     jj_scanpos = xsp;
36095     if (jj_scan_token(45)) {
36096     jj_scanpos = xsp;
36097     if (jj_scan_token(344)) {
36098     jj_scanpos = xsp;
36099     if (jj_scan_token(345)) {
36100     jj_scanpos = xsp;
36101     if (jj_scan_token(53)) {
36102     jj_scanpos = xsp;
36103     if (jj_scan_token(389)) {
36104     jj_scanpos = xsp;
36105     if (jj_scan_token(54)) {
36106     jj_scanpos = xsp;
36107     if (jj_scan_token(346)) {
36108     jj_scanpos = xsp;
36109     if (jj_scan_token(408)) {
36110     jj_scanpos = xsp;
36111     if (jj_scan_token(55)) {
36112     jj_scanpos = xsp;
36113     if (jj_scan_token(322)) {
36114     jj_scanpos = xsp;
36115     if (jj_scan_token(312)) {
36116     jj_scanpos = xsp;
36117     if (jj_scan_token(313)) {
36118     jj_scanpos = xsp;
36119     if (jj_scan_token(395)) {
36120     jj_scanpos = xsp;
36121     if (jj_scan_token(62)) {
36122     jj_scanpos = xsp;
36123     if (jj_scan_token(64)) {
36124     jj_scanpos = xsp;
36125     if (jj_scan_token(349)) {
36126     jj_scanpos = xsp;
36127     if (jj_scan_token(65)) {
36128     jj_scanpos = xsp;
36129     if (jj_scan_token(390)) {
36130     jj_scanpos = xsp;
36131     if (jj_scan_token(401)) {
36132     jj_scanpos = xsp;
36133     if (jj_scan_token(320)) {
36134     jj_scanpos = xsp;
36135     if (jj_scan_token(376)) {
36136     jj_scanpos = xsp;
36137     if (jj_scan_token(375)) {
36138     jj_scanpos = xsp;
36139     if (jj_scan_token(314)) {
36140     jj_scanpos = xsp;
36141     if (jj_scan_token(70)) {
36142     jj_scanpos = xsp;
36143     if (jj_scan_token(72)) {
36144     jj_scanpos = xsp;
36145     if (jj_scan_token(73)) {
36146     jj_scanpos = xsp;
36147     if (jj_scan_token(74)) {
36148     jj_scanpos = xsp;
36149     if (jj_scan_token(75)) {
36150     jj_scanpos = xsp;
36151     if (jj_scan_token(76)) {
36152     jj_scanpos = xsp;
36153     if (jj_scan_token(347)) {
36154     jj_scanpos = xsp;
36155     if (jj_scan_token(80)) {
36156     jj_scanpos = xsp;
36157     if (jj_scan_token(370)) {
36158     jj_scanpos = xsp;
36159     if (jj_scan_token(81)) {
36160     jj_scanpos = xsp;
36161     if (jj_scan_token(82)) {
36162     jj_scanpos = xsp;
36163     if (jj_scan_token(379)) {
36164     jj_scanpos = xsp;
36165     if (jj_scan_token(84)) {
36166     jj_scanpos = xsp;
36167     if (jj_scan_token(37)) {
36168     jj_scanpos = xsp;
36169     if (jj_scan_token(86)) {
36170     jj_scanpos = xsp;
36171     if (jj_scan_token(87)) {
36172     jj_scanpos = xsp;
36173     if (jj_scan_token(348)) {
36174     jj_scanpos = xsp;
36175     if (jj_scan_token(89)) {
36176     jj_scanpos = xsp;
36177     if (jj_scan_token(406)) {
36178     jj_scanpos = xsp;
36179     if (jj_scan_token(350)) {
36180     jj_scanpos = xsp;
36181     if (jj_scan_token(301)) {
36182     jj_scanpos = xsp;
36183     if (jj_scan_token(380)) {
36184     jj_scanpos = xsp;
36185     if (jj_scan_token(36)) {
36186     jj_scanpos = xsp;
36187     if (jj_scan_token(411)) {
36188     jj_scanpos = xsp;
36189     if (jj_scan_token(96)) {
36190     jj_scanpos = xsp;
36191     if (jj_scan_token(351)) {
36192     jj_scanpos = xsp;
36193     if (jj_scan_token(381)) {
36194     jj_scanpos = xsp;
36195     if (jj_scan_token(300)) {
36196     jj_scanpos = xsp;
36197     if (jj_scan_token(352)) {
36198     jj_scanpos = xsp;
36199     if (jj_scan_token(101)) {
36200     jj_scanpos = xsp;
36201     if (jj_scan_token(396)) {
36202     jj_scanpos = xsp;
36203     if (jj_scan_token(104)) {
36204     jj_scanpos = xsp;
36205     if (jj_scan_token(106)) {
36206     jj_scanpos = xsp;
36207     if (jj_scan_token(107)) {
36208     jj_scanpos = xsp;
36209     if (jj_scan_token(109)) {
36210     jj_scanpos = xsp;
36211     if (jj_scan_token(113)) {
36212     jj_scanpos = xsp;
36213     if (jj_scan_token(115)) {
36214     jj_scanpos = xsp;
36215     if (jj_scan_token(114)) {
36216     jj_scanpos = xsp;
36217     if (jj_scan_token(116)) {
36218     jj_scanpos = xsp;
36219     if (jj_scan_token(119)) {
36220     jj_scanpos = xsp;
36221     if (jj_scan_token(353)) {
36222     jj_scanpos = xsp;
36223     if (jj_scan_token(123)) {
36224     jj_scanpos = xsp;
36225     if (jj_scan_token(125)) {
36226     jj_scanpos = xsp;
36227     if (jj_scan_token(126)) {
36228     jj_scanpos = xsp;
36229     if (jj_scan_token(130)) {
36230     jj_scanpos = xsp;
36231     if (jj_scan_token(132)) {
36232     jj_scanpos = xsp;
36233     if (jj_scan_token(382)) {
36234     jj_scanpos = xsp;
36235     if (jj_scan_token(133)) {
36236     jj_scanpos = xsp;
36237     if (jj_scan_token(136)) {
36238     jj_scanpos = xsp;
36239     if (jj_scan_token(142)) {
36240     jj_scanpos = xsp;
36241     if (jj_scan_token(143)) {
36242     jj_scanpos = xsp;
36243     if (jj_scan_token(140)) {
36244     jj_scanpos = xsp;
36245     if (jj_scan_token(145)) {
36246     jj_scanpos = xsp;
36247     if (jj_scan_token(149)) {
36248     jj_scanpos = xsp;
36249     if (jj_scan_token(151)) {
36250     jj_scanpos = xsp;
36251     if (jj_scan_token(153)) {
36252     jj_scanpos = xsp;
36253     if (jj_scan_token(154)) {
36254     jj_scanpos = xsp;
36255     if (jj_scan_token(42)) {
36256     jj_scanpos = xsp;
36257     if (jj_scan_token(399)) {
36258     jj_scanpos = xsp;
36259     if (jj_scan_token(393)) {
36260     jj_scanpos = xsp;
36261     if (jj_scan_token(372)) {
36262     jj_scanpos = xsp;
36263     if (jj_scan_token(155)) {
36264     jj_scanpos = xsp;
36265     if (jj_scan_token(367)) {
36266     jj_scanpos = xsp;
36267     if (jj_scan_token(157)) {
36268     jj_scanpos = xsp;
36269     if (jj_scan_token(409)) {
36270     jj_scanpos = xsp;
36271     if (jj_scan_token(317)) {
36272     jj_scanpos = xsp;
36273     if (jj_scan_token(354)) {
36274     jj_scanpos = xsp;
36275     if (jj_scan_token(355)) {
36276     jj_scanpos = xsp;
36277     if (jj_scan_token(162)) {
36278     jj_scanpos = xsp;
36279     if (jj_scan_token(163)) {
36280     jj_scanpos = xsp;
36281     if (jj_scan_token(374)) {
36282     jj_scanpos = xsp;
36283     if (jj_scan_token(164)) {
36284     jj_scanpos = xsp;
36285     if (jj_scan_token(165)) {
36286     jj_scanpos = xsp;
36287     if (jj_scan_token(166)) {
36288     jj_scanpos = xsp;
36289     if (jj_scan_token(168)) {
36290     jj_scanpos = xsp;
36291     if (jj_scan_token(169)) {
36292     jj_scanpos = xsp;
36293     if (jj_scan_token(170)) {
36294     jj_scanpos = xsp;
36295     if (jj_scan_token(173)) {
36296     jj_scanpos = xsp;
36297     if (jj_scan_token(397)) {
36298     jj_scanpos = xsp;
36299     if (jj_scan_token(368)) {
36300     jj_scanpos = xsp;
36301     if (jj_scan_token(174)) {
36302     jj_scanpos = xsp;
36303     if (jj_scan_token(306)) {
36304     jj_scanpos = xsp;
36305     if (jj_scan_token(402)) {
36306     jj_scanpos = xsp;
36307     if (jj_scan_token(315)) {
36308     jj_scanpos = xsp;
36309     if (jj_scan_token(356)) {
36310     jj_scanpos = xsp;
36311     if (jj_scan_token(176)) {
36312     jj_scanpos = xsp;
36313     if (jj_scan_token(179)) {
36314     jj_scanpos = xsp;
36315     if (jj_scan_token(357)) {
36316     jj_scanpos = xsp;
36317     if (jj_scan_token(304)) {
36318     jj_scanpos = xsp;
36319     if (jj_scan_token(307)) {
36320     jj_scanpos = xsp;
36321     if (jj_scan_token(193)) {
36322     jj_scanpos = xsp;
36323     if (jj_scan_token(196)) {
36324     jj_scanpos = xsp;
36325     if (jj_scan_token(326)) {
36326     jj_scanpos = xsp;
36327     if (jj_scan_token(199)) {
36328     jj_scanpos = xsp;
36329     if (jj_scan_token(200)) {
36330     jj_scanpos = xsp;
36331     if (jj_scan_token(205)) {
36332     jj_scanpos = xsp;
36333     if (jj_scan_token(206)) {
36334     jj_scanpos = xsp;
36335     if (jj_scan_token(208)) {
36336     jj_scanpos = xsp;
36337     if (jj_scan_token(209)) {
36338     jj_scanpos = xsp;
36339     if (jj_scan_token(371)) {
36340     jj_scanpos = xsp;
36341     if (jj_scan_token(327)) {
36342     jj_scanpos = xsp;
36343     if (jj_scan_token(211)) {
36344     jj_scanpos = xsp;
36345     if (jj_scan_token(302)) {
36346     jj_scanpos = xsp;
36347     if (jj_scan_token(219)) {
36348     jj_scanpos = xsp;
36349     if (jj_scan_token(383)) {
36350     jj_scanpos = xsp;
36351     if (jj_scan_token(223)) {
36352     jj_scanpos = xsp;
36353     if (jj_scan_token(384)) {
36354     jj_scanpos = xsp;
36355     if (jj_scan_token(226)) {
36356     jj_scanpos = xsp;
36357     if (jj_scan_token(228)) {
36358     jj_scanpos = xsp;
36359     if (jj_scan_token(229)) {
36360     jj_scanpos = xsp;
36361     if (jj_scan_token(230)) {
36362     jj_scanpos = xsp;
36363     if (jj_scan_token(232)) {
36364     jj_scanpos = xsp;
36365     if (jj_scan_token(385)) {
36366     jj_scanpos = xsp;
36367     if (jj_scan_token(235)) {
36368     jj_scanpos = xsp;
36369     if (jj_scan_token(237)) {
36370     jj_scanpos = xsp;
36371     if (jj_scan_token(238)) {
36372     jj_scanpos = xsp;
36373     if (jj_scan_token(239)) {
36374     jj_scanpos = xsp;
36375     if (jj_scan_token(394)) {
36376     jj_scanpos = xsp;
36377     if (jj_scan_token(241)) {
36378     jj_scanpos = xsp;
36379     if (jj_scan_token(242)) {
36380     jj_scanpos = xsp;
36381     if (jj_scan_token(244)) {
36382     jj_scanpos = xsp;
36383     if (jj_scan_token(245)) {
36384     jj_scanpos = xsp;
36385     if (jj_scan_token(243)) {
36386     jj_scanpos = xsp;
36387     if (jj_scan_token(247)) {
36388     jj_scanpos = xsp;
36389     if (jj_scan_token(248)) {
36390     jj_scanpos = xsp;
36391     if (jj_scan_token(358)) {
36392     jj_scanpos = xsp;
36393     if (jj_scan_token(249)) {
36394     jj_scanpos = xsp;
36395     if (jj_scan_token(251)) {
36396     jj_scanpos = xsp;
36397     if (jj_scan_token(359)) {
36398     jj_scanpos = xsp;
36399     if (jj_scan_token(407)) {
36400     jj_scanpos = xsp;
36401     if (jj_scan_token(253)) {
36402     jj_scanpos = xsp;
36403     if (jj_scan_token(410)) {
36404     jj_scanpos = xsp;
36405     if (jj_scan_token(360)) {
36406     jj_scanpos = xsp;
36407     if (jj_scan_token(257)) {
36408     jj_scanpos = xsp;
36409     if (jj_scan_token(361)) {
36410     jj_scanpos = xsp;
36411     if (jj_scan_token(362)) {
36412     jj_scanpos = xsp;
36413     if (jj_scan_token(262)) {
36414     jj_scanpos = xsp;
36415     if (jj_scan_token(363)) {
36416     jj_scanpos = xsp;
36417     if (jj_scan_token(369)) {
36418     jj_scanpos = xsp;
36419     if (jj_scan_token(398)) {
36420     jj_scanpos = xsp;
36421     if (jj_scan_token(265)) {
36422     jj_scanpos = xsp;
36423     if (jj_scan_token(264)) {
36424     jj_scanpos = xsp;
36425     if (jj_scan_token(266)) {
36426     jj_scanpos = xsp;
36427     if (jj_scan_token(364)) {
36428     jj_scanpos = xsp;
36429     if (jj_scan_token(373)) {
36430     jj_scanpos = xsp;
36431     if (jj_scan_token(272)) {
36432     jj_scanpos = xsp;
36433     if (jj_scan_token(274)) {
36434     jj_scanpos = xsp;
36435     if (jj_scan_token(275)) {
36436     jj_scanpos = xsp;
36437     if (jj_scan_token(277)) {
36438     jj_scanpos = xsp;
36439     if (jj_scan_token(279)) {
36440     jj_scanpos = xsp;
36441     if (jj_scan_token(278)) {
36442     jj_scanpos = xsp;
36443     if (jj_scan_token(276)) {
36444     jj_scanpos = xsp;
36445     if (jj_scan_token(400)) {
36446     jj_scanpos = xsp;
36447     if (jj_scan_token(281)) {
36448     jj_scanpos = xsp;
36449     if (jj_scan_token(391)) {
36450     jj_scanpos = xsp;
36451     if (jj_scan_token(392)) {
36452     jj_scanpos = xsp;
36453     if (jj_scan_token(365)) {
36454     jj_scanpos = xsp;
36455     if (jj_scan_token(386)) {
36456     jj_scanpos = xsp;
36457     if (jj_scan_token(286)) {
36458     jj_scanpos = xsp;
36459     if (jj_scan_token(309)) {
36460     jj_scanpos = xsp;
36461     if (jj_scan_token(412)) {
36462     jj_scanpos = xsp;
36463     if (jj_scan_token(288)) {
36464     jj_scanpos = xsp;
36465     if (jj_scan_token(310)) {
36466     jj_scanpos = xsp;
36467     if (jj_scan_token(387)) {
36468     jj_scanpos = xsp;
36469     if (jj_scan_token(311)) {
36470     jj_scanpos = xsp;
36471     if (jj_scan_token(388)) {
36472     jj_scanpos = xsp;
36473     if (jj_scan_token(316)) {
36474     jj_scanpos = xsp;
36475     if (jj_scan_token(293)) {
36476     jj_scanpos = xsp;
36477     if (jj_scan_token(319)) {
36478     jj_scanpos = xsp;
36479     if (jj_scan_token(294)) {
36480     jj_scanpos = xsp;
36481     if (jj_scan_token(366)) {
36482     jj_scanpos = xsp;
36483     if (jj_scan_token(270)) {
36484     jj_scanpos = xsp;
36485     if (jj_scan_token(100)) {
36486     jj_scanpos = xsp;
36487     if (jj_scan_token(182)) {
36488     jj_scanpos = xsp;
36489     if (jj_scan_token(378)) {
36490     jj_scanpos = xsp;
36491     if (jj_scan_token(186)) {
36492     jj_scanpos = xsp;
36493     if (jj_scan_token(233)) {
36494     jj_scanpos = xsp;
36495     if (jj_scan_token(231)) {
36496     jj_scanpos = xsp;
36497     if (jj_scan_token(43)) return true;
36498     }
36499     }
36500     }
36501     }
36502     }
36503     }
36504     }
36505     }
36506     }
36507     }
36508     }
36509     }
36510     }
36511     }
36512     }
36513     }
36514     }
36515     }
36516     }
36517     }
36518     }
36519     }
36520     }
36521     }
36522     }
36523     }
36524     }
36525     }
36526     }
36527     }
36528     }
36529     }
36530     }
36531     }
36532     }
36533     }
36534     }
36535     }
36536     }
36537     }
36538     }
36539     }
36540     }
36541     }
36542     }
36543     }
36544     }
36545     }
36546     }
36547     }
36548     }
36549     }
36550     }
36551     }
36552     }
36553     }
36554     }
36555     }
36556     }
36557     }
36558     }
36559     }
36560     }
36561     }
36562     }
36563     }
36564     }
36565     }
36566     }
36567     }
36568     }
36569     }
36570     }
36571     }
36572     }
36573     }
36574     }
36575     }
36576     }
36577     }
36578     }
36579     }
36580     }
36581     }
36582     }
36583     }
36584     }
36585     }
36586     }
36587     }
36588     }
36589     }
36590     }
36591     }
36592     }
36593     }
36594     }
36595     }
36596     }
36597     }
36598     }
36599     }
36600     }
36601     }
36602     }
36603     }
36604     }
36605     }
36606     }
36607     }
36608     }
36609     }
36610     }
36611     }
36612     }
36613     }
36614     }
36615     }
36616     }
36617     }
36618     }
36619     }
36620     }
36621     }
36622     }
36623     }
36624     }
36625     }
36626     }
36627     }
36628     }
36629     }
36630     }
36631     }
36632     }
36633     }
36634     }
36635     }
36636     }
36637     }
36638     }
36639     }
36640     }
36641     }
36642     }
36643     }
36644     }
36645     }
36646     }
36647     }
36648     }
36649     }
36650     }
36651     }
36652     }
36653     }
36654     }
36655     }
36656     }
36657     }
36658     }
36659     }
36660     }
36661     }
36662     }
36663     }
36664     }
36665     }
36666     }
36667     }
36668     }
36669     }
36670     }
36671     }
36672     }
36673     }
36674     }
36675     }
36676     }
36677     }
36678     }
36679     }
36680     }
36681     }
36682     }
36683     }
36684     }
36685     }
36686     }
36687     }
36688     }
36689     }
36690     }
36691     }
36692     }
36693     }
36694     }
36695     }
36696     }
36697     }
36698     }
36699     }
36700     }
36701     }
36702     }
36703     }
36704     }
36705     return false;
36706   }
36707 
36708   private boolean jj_3_32() {
36709     if (jj_scan_token(INTERVAL)) return true;
36710     if (jj_scan_token(DAY)) return true;
36711     return false;
36712   }
36713 
36714   private boolean jj_3_31() {
36715     if (jj_scan_token(INTERVAL)) return true;
36716     if (jj_scan_token(YEAR)) return true;
36717     return false;
36718   }
36719 
36720   private boolean jj_3R_299() {
36721     if (jj_scan_token(5)) return true;
36722     Token xsp;
36723     xsp = jj_scanpos;
36724     if (jj_3R_342()) jj_scanpos = xsp;
36725     if (jj_scan_token(7)) return true;
36726     return false;
36727   }
36728 
36729   private boolean jj_3R_353() {
36730     if (jj_scan_token(3)) return true;
36731     if (jj_3R_120()) return true;
36732     return false;
36733   }
36734 
36735   private boolean jj_3R_205() {
36736     if (jj_scan_token(REF)) return true;
36737     if (jj_scan_token(CURSOR)) return true;
36738     return false;
36739   }
36740 
36741   private boolean jj_3R_128() {
36742     if (jj_3R_143()) return true;
36743     Token xsp;
36744     while (true) {
36745       xsp = jj_scanpos;
36746       if (jj_3R_353()) { jj_scanpos = xsp; break; }
36747     }
36748     return false;
36749   }
36750 
36751   private boolean jj_3_30() {
36752     if (jj_scan_token(LONG)) return true;
36753     if (jj_scan_token(RAW)) return true;
36754     return false;
36755   }
36756 
36757   private boolean jj_3R_141() {
36758     if (jj_scan_token(3)) return true;
36759     return false;
36760   }
36761 
36762   private boolean jj_3R_204() {
36763     Token xsp;
36764     xsp = jj_scanpos;
36765     if (jj_scan_token(67)) {
36766     jj_scanpos = xsp;
36767     if (jj_scan_token(320)) {
36768     jj_scanpos = xsp;
36769     if (jj_3_30()) {
36770     jj_scanpos = xsp;
36771     if (jj_scan_token(160)) {
36772     jj_scanpos = xsp;
36773     if (jj_scan_token(306)) {
36774     jj_scanpos = xsp;
36775     if (jj_scan_token(307)) {
36776     jj_scanpos = xsp;
36777     if (jj_scan_token(227)) {
36778     jj_scanpos = xsp;
36779     if (jj_scan_token(244)) {
36780     jj_scanpos = xsp;
36781     if (jj_scan_token(308)) {
36782     jj_scanpos = xsp;
36783     if (jj_scan_token(309)) {
36784     jj_scanpos = xsp;
36785     if (jj_scan_token(298)) {
36786     jj_scanpos = xsp;
36787     if (jj_scan_token(299)) {
36788     jj_scanpos = xsp;
36789     if (jj_scan_token(314)) {
36790     jj_scanpos = xsp;
36791     if (jj_scan_token(315)) return true;
36792     }
36793     }
36794     }
36795     }
36796     }
36797     }
36798     }
36799     }
36800     }
36801     }
36802     }
36803     }
36804     }
36805     return false;
36806   }
36807 
36808   private boolean jj_3_58() {
36809     Token xsp;
36810     xsp = jj_scanpos;
36811     if (jj_3R_141()) {
36812     jj_scanpos = xsp;
36813     if (jj_3R_142()) return true;
36814     }
36815     if (jj_3R_120()) return true;
36816     return false;
36817   }
36818 
36819   private boolean jj_3R_295() {
36820     if (jj_3R_143()) return true;
36821     Token xsp;
36822     while (true) {
36823       xsp = jj_scanpos;
36824       if (jj_3_58()) { jj_scanpos = xsp; break; }
36825     }
36826     return false;
36827   }
36828 
36829   private boolean jj_3R_191() {
36830     if (jj_scan_token(21)) return true;
36831     if (jj_3R_143()) return true;
36832     if (jj_scan_token(22)) return true;
36833     return false;
36834   }
36835 
36836   private boolean jj_3R_126() {
36837     Token xsp;
36838     xsp = jj_scanpos;
36839     if (jj_scan_token(188)) {
36840     jj_scanpos = xsp;
36841     if (jj_scan_token(189)) {
36842     jj_scanpos = xsp;
36843     if (jj_scan_token(68)) {
36844     jj_scanpos = xsp;
36845     if (jj_scan_token(190)) {
36846     jj_scanpos = xsp;
36847     if (jj_scan_token(191)) {
36848     jj_scanpos = xsp;
36849     if (jj_scan_token(192)) {
36850     jj_scanpos = xsp;
36851     if (jj_scan_token(59)) {
36852     jj_scanpos = xsp;
36853     if (jj_scan_token(301)) {
36854     jj_scanpos = xsp;
36855     if (jj_scan_token(91)) {
36856     jj_scanpos = xsp;
36857     if (jj_3R_203()) {
36858     jj_scanpos = xsp;
36859     if (jj_scan_token(120)) {
36860     jj_scanpos = xsp;
36861     if (jj_scan_token(303)) {
36862     jj_scanpos = xsp;
36863     if (jj_scan_token(146)) {
36864     jj_scanpos = xsp;
36865     if (jj_scan_token(174)) {
36866     jj_scanpos = xsp;
36867     if (jj_scan_token(175)) {
36868     jj_scanpos = xsp;
36869     if (jj_scan_token(187)) {
36870     jj_scanpos = xsp;
36871     if (jj_scan_token(304)) {
36872     jj_scanpos = xsp;
36873     if (jj_scan_token(215)) {
36874     jj_scanpos = xsp;
36875     if (jj_scan_token(216)) {
36876     jj_scanpos = xsp;
36877     if (jj_scan_token(217)) {
36878     jj_scanpos = xsp;
36879     if (jj_scan_token(228)) {
36880     jj_scanpos = xsp;
36881     if (jj_scan_token(305)) {
36882     jj_scanpos = xsp;
36883     if (jj_scan_token(256)) {
36884     jj_scanpos = xsp;
36885     if (jj_3R_204()) {
36886     jj_scanpos = xsp;
36887     if (jj_scan_token(61)) {
36888     jj_scanpos = xsp;
36889     if (jj_scan_token(312)) {
36890     jj_scanpos = xsp;
36891     if (jj_scan_token(313)) {
36892     jj_scanpos = xsp;
36893     if (jj_scan_token(270)) {
36894     jj_scanpos = xsp;
36895     if (jj_3R_205()) {
36896     jj_scanpos = xsp;
36897     if (jj_scan_token(88)) {
36898     jj_scanpos = xsp;
36899     if (jj_3_31()) {
36900     jj_scanpos = xsp;
36901     if (jj_3_32()) {
36902     jj_scanpos = xsp;
36903     if (jj_scan_token(274)) {
36904     jj_scanpos = xsp;
36905     if (jj_scan_token(275)) {
36906     jj_scanpos = xsp;
36907     if (jj_3R_206()) return true;
36908     }
36909     }
36910     }
36911     }
36912     }
36913     }
36914     }
36915     }
36916     }
36917     }
36918     }
36919     }
36920     }
36921     }
36922     }
36923     }
36924     }
36925     }
36926     }
36927     }
36928     }
36929     }
36930     }
36931     }
36932     }
36933     }
36934     }
36935     }
36936     }
36937     }
36938     }
36939     }
36940     }
36941     }
36942     xsp = jj_scanpos;
36943     if (jj_3_33()) jj_scanpos = xsp;
36944     xsp = jj_scanpos;
36945     if (jj_3R_207()) jj_scanpos = xsp;
36946     return false;
36947   }
36948 
36949   private boolean jj_3R_240() {
36950     if (jj_scan_token(VARYING)) return true;
36951     if (jj_scan_token(ARRAY)) return true;
36952     return false;
36953   }
36954 
36955   private boolean jj_3_29() {
36956     if (jj_scan_token(5)) return true;
36957     if (jj_3R_127()) return true;
36958     return false;
36959   }
36960 
36961   private boolean jj_3R_127() {
36962     if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36963     return false;
36964   }
36965 
36966   private boolean jj_3R_146() {
36967     Token xsp;
36968     xsp = jj_scanpos;
36969     if (jj_scan_token(271)) {
36970     jj_scanpos = xsp;
36971     if (jj_scan_token(310)) {
36972     jj_scanpos = xsp;
36973     if (jj_3R_240()) return true;
36974     }
36975     }
36976     xsp = jj_scanpos;
36977     if (jj_3_29()) jj_scanpos = xsp;
36978     return false;
36979   }
36980 
36981   private boolean jj_3R_400() {
36982     if (jj_scan_token(CC_ELSE)) return true;
36983     if (jj_3R_236()) return true;
36984     return false;
36985   }
36986 
36987   private boolean jj_3R_227() {
36988     if (jj_scan_token(A)) return true;
36989     if (jj_scan_token(SET)) return true;
36990     return false;
36991   }
36992 
36993   private boolean jj_3R_137() {
36994     Token xsp;
36995     xsp = jj_scanpos;
36996     if (jj_3R_227()) {
36997     jj_scanpos = xsp;
36998     if (jj_scan_token(396)) return true;
36999     }
37000     return false;
37001   }
37002 
37003   private boolean jj_3R_399() {
37004     if (jj_scan_token(CC_ELSIF)) return true;
37005     if (jj_3R_344()) return true;
37006     if (jj_scan_token(CC_THEN)) return true;
37007     if (jj_3R_236()) return true;
37008     return false;
37009   }
37010 
37011   private boolean jj_3R_392() {
37012     if (jj_scan_token(NULL)) return true;
37013     return false;
37014   }
37015 
37016   private boolean jj_3R_346() {
37017     if (jj_scan_token(CC_IF)) return true;
37018     if (jj_3R_344()) return true;
37019     if (jj_scan_token(CC_THEN)) return true;
37020     if (jj_3R_236()) return true;
37021     Token xsp;
37022     while (true) {
37023       xsp = jj_scanpos;
37024       if (jj_3R_399()) { jj_scanpos = xsp; break; }
37025     }
37026     while (true) {
37027       xsp = jj_scanpos;
37028       if (jj_3R_400()) { jj_scanpos = xsp; break; }
37029     }
37030     if (jj_scan_token(CC_END)) return true;
37031     return false;
37032   }
37033 
37034   private boolean jj_3R_348() {
37035     if (jj_scan_token(11)) return true;
37036     Token xsp;
37037     xsp = jj_scanpos;
37038     if (jj_scan_token(284)) {
37039     jj_scanpos = xsp;
37040     if (jj_scan_token(246)) return true;
37041     }
37042     return false;
37043   }
37044 
37045   private boolean jj_3R_347() {
37046     if (jj_scan_token(2)) return true;
37047     if (jj_3R_128()) return true;
37048     return false;
37049   }
37050 
37051   private boolean jj_3_27() {
37052     if (jj_scan_token(REF)) return true;
37053     return false;
37054   }
37055 
37056   private boolean jj_3R_305() {
37057     Token xsp;
37058     xsp = jj_scanpos;
37059     if (jj_3_27()) jj_scanpos = xsp;
37060     if (jj_3R_128()) return true;
37061     xsp = jj_scanpos;
37062     if (jj_3R_347()) jj_scanpos = xsp;
37063     xsp = jj_scanpos;
37064     if (jj_3R_348()) jj_scanpos = xsp;
37065     return false;
37066   }
37067 
37068   private boolean jj_3_28() {
37069     if (jj_3R_126()) return true;
37070     return false;
37071   }
37072 
37073   private boolean jj_3R_304() {
37074     if (jj_3R_346()) return true;
37075     return false;
37076   }
37077 
37078   private boolean jj_3R_391() {
37079     Token xsp;
37080     xsp = jj_scanpos;
37081     if (jj_scan_token(283)) {
37082     jj_scanpos = xsp;
37083     if (jj_scan_token(117)) return true;
37084     }
37085     return false;
37086   }
37087 
37088   private boolean jj_3R_236() {
37089     Token xsp;
37090     xsp = jj_scanpos;
37091     if (jj_3R_304()) {
37092     jj_scanpos = xsp;
37093     if (jj_3_28()) {
37094     jj_scanpos = xsp;
37095     if (jj_3R_305()) return true;
37096     }
37097     }
37098     return false;
37099   }
37100 
37101   private boolean jj_3R_335() {
37102     if (jj_scan_token(_DEFAULT)) return true;
37103     return false;
37104   }
37105 
37106   private boolean jj_3R_336() {
37107     if (jj_3R_234()) return true;
37108     return false;
37109   }
37110 
37111   private boolean jj_3R_284() {
37112     if (jj_3R_124()) return true;
37113     return false;
37114   }
37115 
37116   private boolean jj_3R_334() {
37117     if (jj_scan_token(9)) return true;
37118     if (jj_scan_token(10)) return true;
37119     return false;
37120   }
37121 
37122   private boolean jj_3R_286() {
37123     Token xsp;
37124     xsp = jj_scanpos;
37125     if (jj_3R_334()) {
37126     jj_scanpos = xsp;
37127     if (jj_3R_335()) return true;
37128     }
37129     if (jj_3R_336()) return true;
37130     return false;
37131   }
37132 
37133   private boolean jj_3R_333() {
37134     if (jj_scan_token(NOT)) return true;
37135     return false;
37136   }
37137 
37138   private boolean jj_3R_183() {
37139     if (jj_scan_token(STRING_LITERAL)) return true;
37140     return false;
37141   }
37142 
37143   private boolean jj_3R_285() {
37144     Token xsp;
37145     xsp = jj_scanpos;
37146     if (jj_3R_333()) jj_scanpos = xsp;
37147     if (jj_scan_token(NULL)) return true;
37148     return false;
37149   }
37150 
37151   private boolean jj_3_26() {
37152     if (jj_scan_token(CONSTANT)) return true;
37153     return false;
37154   }
37155 
37156   private boolean jj_3R_198() {
37157     if (jj_3R_284()) return true;
37158     Token xsp;
37159     xsp = jj_scanpos;
37160     if (jj_3_26()) jj_scanpos = xsp;
37161     if (jj_3R_236()) return true;
37162     xsp = jj_scanpos;
37163     if (jj_3R_285()) jj_scanpos = xsp;
37164     xsp = jj_scanpos;
37165     if (jj_3R_286()) jj_scanpos = xsp;
37166     return false;
37167   }
37168 
37169   private boolean jj_3R_515() {
37170     if (jj_scan_token(6)) return true;
37171     if (jj_3R_475()) return true;
37172     return false;
37173   }
37174 
37175   private boolean jj_3R_428() {
37176     if (jj_3R_475()) return true;
37177     Token xsp;
37178     while (true) {
37179       xsp = jj_scanpos;
37180       if (jj_3R_515()) { jj_scanpos = xsp; break; }
37181     }
37182     return false;
37183   }
37184 
37185   private boolean jj_3R_197() {
37186     if (jj_3R_283()) return true;
37187     return false;
37188   }
37189 
37190   private boolean jj_3R_386() {
37191     if (jj_scan_token(5)) return true;
37192     Token xsp;
37193     xsp = jj_scanpos;
37194     if (jj_3R_428()) jj_scanpos = xsp;
37195     if (jj_scan_token(7)) return true;
37196     return false;
37197   }
37198 
37199   private boolean jj_3R_341() {
37200     if (jj_3R_393()) return true;
37201     return false;
37202   }
37203 
37204   private boolean jj_3R_340() {
37205     if (jj_3R_392()) return true;
37206     return false;
37207   }
37208 
37209   private boolean jj_3R_339() {
37210     if (jj_3R_391()) return true;
37211     return false;
37212   }
37213 
37214   private boolean jj_3_23() {
37215     if (jj_scan_token(NOCOPY)) return true;
37216     return false;
37217   }
37218 
37219   private boolean jj_3R_338() {
37220     if (jj_3R_183()) return true;
37221     return false;
37222   }
37223 
37224   private boolean jj_3R_326() {
37225     if (jj_3R_386()) return true;
37226     return false;
37227   }
37228 
37229   private boolean jj_3R_120() {
37230     Token xsp;
37231     xsp = jj_scanpos;
37232     if (jj_scan_token(420)) {
37233     jj_scanpos = xsp;
37234     if (jj_scan_token(428)) {
37235     jj_scanpos = xsp;
37236     if (jj_3R_197()) {
37237     jj_scanpos = xsp;
37238     if (jj_scan_token(35)) {
37239     jj_scanpos = xsp;
37240     if (jj_scan_token(38)) {
37241     jj_scanpos = xsp;
37242     if (jj_scan_token(39)) {
37243     jj_scanpos = xsp;
37244     if (jj_scan_token(40)) {
37245     jj_scanpos = xsp;
37246     if (jj_scan_token(41)) {
37247     jj_scanpos = xsp;
37248     if (jj_scan_token(50)) {
37249     jj_scanpos = xsp;
37250     if (jj_scan_token(56)) {
37251     jj_scanpos = xsp;
37252     if (jj_scan_token(59)) {
37253     jj_scanpos = xsp;
37254     if (jj_scan_token(60)) {
37255     jj_scanpos = xsp;
37256     if (jj_scan_token(61)) {
37257     jj_scanpos = xsp;
37258     if (jj_scan_token(67)) {
37259     jj_scanpos = xsp;
37260     if (jj_scan_token(68)) {
37261     jj_scanpos = xsp;
37262     if (jj_scan_token(79)) {
37263     jj_scanpos = xsp;
37264     if (jj_scan_token(85)) {
37265     jj_scanpos = xsp;
37266     if (jj_scan_token(88)) {
37267     jj_scanpos = xsp;
37268     if (jj_scan_token(91)) {
37269     jj_scanpos = xsp;
37270     if (jj_scan_token(93)) {
37271     jj_scanpos = xsp;
37272     if (jj_scan_token(98)) {
37273     jj_scanpos = xsp;
37274     if (jj_scan_token(103)) {
37275     jj_scanpos = xsp;
37276     if (jj_scan_token(111)) {
37277     jj_scanpos = xsp;
37278     if (jj_scan_token(112)) {
37279     jj_scanpos = xsp;
37280     if (jj_scan_token(120)) {
37281     jj_scanpos = xsp;
37282     if (jj_scan_token(122)) {
37283     jj_scanpos = xsp;
37284     if (jj_scan_token(146)) {
37285     jj_scanpos = xsp;
37286     if (jj_scan_token(147)) {
37287     jj_scanpos = xsp;
37288     if (jj_scan_token(160)) {
37289     jj_scanpos = xsp;
37290     if (jj_scan_token(161)) {
37291     jj_scanpos = xsp;
37292     if (jj_scan_token(171)) {
37293     jj_scanpos = xsp;
37294     if (jj_scan_token(175)) {
37295     jj_scanpos = xsp;
37296     if (jj_scan_token(178)) {
37297     jj_scanpos = xsp;
37298     if (jj_scan_token(181)) {
37299     jj_scanpos = xsp;
37300     if (jj_scan_token(187)) {
37301     jj_scanpos = xsp;
37302     if (jj_scan_token(188)) {
37303     jj_scanpos = xsp;
37304     if (jj_scan_token(189)) {
37305     jj_scanpos = xsp;
37306     if (jj_scan_token(190)) {
37307     jj_scanpos = xsp;
37308     if (jj_scan_token(191)) {
37309     jj_scanpos = xsp;
37310     if (jj_scan_token(192)) {
37311     jj_scanpos = xsp;
37312     if (jj_scan_token(194)) {
37313     jj_scanpos = xsp;
37314     if (jj_scan_token(201)) {
37315     jj_scanpos = xsp;
37316     if (jj_scan_token(207)) {
37317     jj_scanpos = xsp;
37318     if (jj_scan_token(215)) {
37319     jj_scanpos = xsp;
37320     if (jj_scan_token(216)) {
37321     jj_scanpos = xsp;
37322     if (jj_scan_token(217)) {
37323     jj_scanpos = xsp;
37324     if (jj_scan_token(218)) {
37325     jj_scanpos = xsp;
37326     if (jj_scan_token(220)) {
37327     jj_scanpos = xsp;
37328     if (jj_scan_token(222)) {
37329     jj_scanpos = xsp;
37330     if (jj_scan_token(221)) {
37331     jj_scanpos = xsp;
37332     if (jj_scan_token(225)) {
37333     jj_scanpos = xsp;
37334     if (jj_scan_token(227)) {
37335     jj_scanpos = xsp;
37336     if (jj_scan_token(246)) {
37337     jj_scanpos = xsp;
37338     if (jj_scan_token(252)) {
37339     jj_scanpos = xsp;
37340     if (jj_scan_token(256)) {
37341     jj_scanpos = xsp;
37342     if (jj_scan_token(259)) {
37343     jj_scanpos = xsp;
37344     if (jj_scan_token(260)) {
37345     jj_scanpos = xsp;
37346     if (jj_scan_token(263)) {
37347     jj_scanpos = xsp;
37348     if (jj_scan_token(267)) {
37349     jj_scanpos = xsp;
37350     if (jj_scan_token(268)) {
37351     jj_scanpos = xsp;
37352     if (jj_scan_token(269)) {
37353     jj_scanpos = xsp;
37354     if (jj_scan_token(282)) {
37355     jj_scanpos = xsp;
37356     if (jj_scan_token(284)) {
37357     jj_scanpos = xsp;
37358     if (jj_scan_token(285)) {
37359     jj_scanpos = xsp;
37360     if (jj_scan_token(298)) {
37361     jj_scanpos = xsp;
37362     if (jj_scan_token(299)) {
37363     jj_scanpos = xsp;
37364     if (jj_scan_token(303)) {
37365     jj_scanpos = xsp;
37366     if (jj_scan_token(305)) {
37367     jj_scanpos = xsp;
37368     if (jj_scan_token(308)) {
37369     jj_scanpos = xsp;
37370     if (jj_scan_token(292)) return true;
37371     }
37372     }
37373     }
37374     }
37375     }
37376     }
37377     }
37378     }
37379     }
37380     }
37381     }
37382     }
37383     }
37384     }
37385     }
37386     }
37387     }
37388     }
37389     }
37390     }
37391     }
37392     }
37393     }
37394     }
37395     }
37396     }
37397     }
37398     }
37399     }
37400     }
37401     }
37402     }
37403     }
37404     }
37405     }
37406     }
37407     }
37408     }
37409     }
37410     }
37411     }
37412     }
37413     }
37414     }
37415     }
37416     }
37417     }
37418     }
37419     }
37420     }
37421     }
37422     }
37423     }
37424     }
37425     }
37426     }
37427     }
37428     }
37429     }
37430     }
37431     }
37432     }
37433     }
37434     }
37435     }
37436     }
37437     }
37438     }
37439     }
37440     return false;
37441   }
37442 
37443   private boolean jj_3R_337() {
37444     if (jj_3R_127()) return true;
37445     return false;
37446   }
37447 
37448   private boolean jj_3R_294() {
37449     Token xsp;
37450     xsp = jj_scanpos;
37451     if (jj_3R_337()) {
37452     jj_scanpos = xsp;
37453     if (jj_scan_token(425)) {
37454     jj_scanpos = xsp;
37455     if (jj_3R_338()) {
37456     jj_scanpos = xsp;
37457     if (jj_3R_339()) {
37458     jj_scanpos = xsp;
37459     if (jj_3R_340()) {
37460     jj_scanpos = xsp;
37461     if (jj_3R_341()) return true;
37462     }
37463     }
37464     }
37465     }
37466     }
37467     return false;
37468   }
37469 
37470   private boolean jj_3R_325() {
37471     if (jj_scan_token(RETURN)) return true;
37472     if (jj_3R_236()) return true;
37473     return false;
37474   }
37475 
37476   private boolean jj_3R_479() {
37477     if (jj_3R_234()) return true;
37478     return false;
37479   }
37480 
37481   private boolean jj_3R_279() {
37482     if (jj_scan_token(PROCEDURE)) return true;
37483     if (jj_3R_155()) return true;
37484     Token xsp;
37485     xsp = jj_scanpos;
37486     if (jj_3R_326()) jj_scanpos = xsp;
37487     return false;
37488   }
37489 
37490   private boolean jj_3R_478() {
37491     if (jj_3R_183()) return true;
37492     return false;
37493   }
37494 
37495   private boolean jj_3R_477() {
37496     if (jj_scan_token(SESSIONTIMEZONE)) return true;
37497     return false;
37498   }
37499 
37500   private boolean jj_3R_476() {
37501     if (jj_scan_token(DBTIMEZONE)) return true;
37502     return false;
37503   }
37504 
37505   private boolean jj_3R_464() {
37506     if (jj_3R_124()) return true;
37507     return false;
37508   }
37509 
37510   private boolean jj_3R_125() {
37511     if (jj_scan_token(IN)) return true;
37512     if (jj_scan_token(OUT)) return true;
37513     return false;
37514   }
37515 
37516   private boolean jj_3R_298() {
37517     if (jj_scan_token(TIME)) return true;
37518     if (jj_scan_token(ZONE)) return true;
37519     Token xsp;
37520     xsp = jj_scanpos;
37521     if (jj_3R_476()) {
37522     jj_scanpos = xsp;
37523     if (jj_3R_477()) {
37524     jj_scanpos = xsp;
37525     if (jj_3R_478()) {
37526     jj_scanpos = xsp;
37527     if (jj_3R_479()) return true;
37528     }
37529     }
37530     }
37531     return false;
37532   }
37533 
37534   private boolean jj_3R_226() {
37535     if (jj_3R_299()) return true;
37536     return false;
37537   }
37538 
37539   private boolean jj_3R_297() {
37540     if (jj_scan_token(LOCAL)) return true;
37541     return false;
37542   }
37543 
37544   private boolean jj_3R_238() {
37545     if (jj_3R_283()) return true;
37546     return false;
37547   }
37548 
37549   private boolean jj_3R_324() {
37550     if (jj_3R_386()) return true;
37551     return false;
37552   }
37553 
37554   private boolean jj_3R_278() {
37555     if (jj_scan_token(FUNCTION)) return true;
37556     if (jj_3R_155()) return true;
37557     Token xsp;
37558     xsp = jj_scanpos;
37559     if (jj_3R_324()) jj_scanpos = xsp;
37560     xsp = jj_scanpos;
37561     if (jj_3R_325()) jj_scanpos = xsp;
37562     return false;
37563   }
37564 
37565   private boolean jj_3R_225() {
37566     if (jj_scan_token(AT)) return true;
37567     Token xsp;
37568     xsp = jj_scanpos;
37569     if (jj_3R_297()) {
37570     jj_scanpos = xsp;
37571     if (jj_3R_298()) return true;
37572     }
37573     return false;
37574   }
37575 
37576   private boolean jj_3R_625() {
37577     if (jj_scan_token(3)) return true;
37578     if (jj_3R_124()) return true;
37579     return false;
37580   }
37581 
37582   private boolean jj_3R_194() {
37583     Token xsp;
37584     xsp = jj_scanpos;
37585     if (jj_3R_278()) {
37586     jj_scanpos = xsp;
37587     if (jj_3R_279()) return true;
37588     }
37589     return false;
37590   }
37591 
37592   private boolean jj_3R_224() {
37593     if (jj_scan_token(2)) return true;
37594     if (jj_3R_120()) return true;
37595     return false;
37596   }
37597 
37598   private boolean jj_3R_624() {
37599     if (jj_scan_token(6)) return true;
37600     if (jj_3R_124()) return true;
37601     return false;
37602   }
37603 
37604   private boolean jj_3R_143() {
37605     Token xsp;
37606     xsp = jj_scanpos;
37607     if (jj_scan_token(420)) {
37608     jj_scanpos = xsp;
37609     if (jj_scan_token(428)) {
37610     jj_scanpos = xsp;
37611     if (jj_3R_238()) {
37612     jj_scanpos = xsp;
37613     if (jj_scan_token(60)) {
37614     jj_scanpos = xsp;
37615     if (jj_scan_token(171)) {
37616     jj_scanpos = xsp;
37617     if (jj_scan_token(201)) {
37618     jj_scanpos = xsp;
37619     if (jj_scan_token(222)) {
37620     jj_scanpos = xsp;
37621     if (jj_scan_token(227)) {
37622     jj_scanpos = xsp;
37623     if (jj_scan_token(35)) {
37624     jj_scanpos = xsp;
37625     if (jj_scan_token(308)) {
37626     jj_scanpos = xsp;
37627     if (jj_scan_token(258)) {
37628     jj_scanpos = xsp;
37629     if (jj_scan_token(259)) {
37630     jj_scanpos = xsp;
37631     if (jj_scan_token(260)) {
37632     jj_scanpos = xsp;
37633     if (jj_scan_token(269)) {
37634     jj_scanpos = xsp;
37635     if (jj_scan_token(284)) {
37636     jj_scanpos = xsp;
37637     if (jj_scan_token(161)) {
37638     jj_scanpos = xsp;
37639     if (jj_scan_token(303)) {
37640     jj_scanpos = xsp;
37641     if (jj_scan_token(50)) return true;
37642     }
37643     }
37644     }
37645     }
37646     }
37647     }
37648     }
37649     }
37650     }
37651     }
37652     }
37653     }
37654     }
37655     }
37656     }
37657     }
37658     }
37659     return false;
37660   }
37661 
37662   private boolean jj_3_24() {
37663     Token xsp;
37664     xsp = jj_scanpos;
37665     if (jj_scan_token(207)) {
37666     jj_scanpos = xsp;
37667     if (jj_3R_125()) return true;
37668     }
37669     xsp = jj_scanpos;
37670     if (jj_3_23()) jj_scanpos = xsp;
37671     return false;
37672   }
37673 
37674   private boolean jj_3R_636() {
37675     if (jj_scan_token(NOT)) return true;
37676     return false;
37677   }
37678 
37679   private boolean jj_3R_223() {
37680     if (jj_scan_token(3)) return true;
37681     if (jj_3R_120()) return true;
37682     return false;
37683   }
37684 
37685   private boolean jj_3R_136() {
37686     Token xsp;
37687     xsp = jj_scanpos;
37688     if (jj_3R_223()) {
37689     jj_scanpos = xsp;
37690     if (jj_3R_224()) {
37691     jj_scanpos = xsp;
37692     if (jj_3R_225()) {
37693     jj_scanpos = xsp;
37694     if (jj_3R_226()) return true;
37695     }
37696     }
37697     }
37698     return false;
37699   }
37700 
37701   private boolean jj_3R_560() {
37702     if (jj_3R_236()) return true;
37703     return false;
37704   }
37705 
37706   private boolean jj_3R_463() {
37707     if (jj_3R_351()) return true;
37708     return false;
37709   }
37710 
37711   private boolean jj_3R_601() {
37712     if (jj_scan_token(6)) return true;
37713     if (jj_3R_124()) return true;
37714     Token xsp;
37715     xsp = jj_scanpos;
37716     if (jj_3R_625()) jj_scanpos = xsp;
37717     return false;
37718   }
37719 
37720   private boolean jj_3R_487() {
37721     if (jj_scan_token(3)) return true;
37722     if (jj_3R_124()) return true;
37723     return false;
37724   }
37725 
37726   private boolean jj_3R_471() {
37727     if (jj_3R_147()) return true;
37728     return false;
37729   }
37730 
37731   private boolean jj_3R_470() {
37732     if (jj_3R_118()) return true;
37733     return false;
37734   }
37735 
37736   private boolean jj_3R_631() {
37737     if (jj_scan_token(NOT)) return true;
37738     return false;
37739   }
37740 
37741   private boolean jj_3R_426() {
37742     Token xsp;
37743     xsp = jj_scanpos;
37744     if (jj_3R_470()) {
37745     jj_scanpos = xsp;
37746     if (jj_3R_471()) return true;
37747     }
37748     return false;
37749   }
37750 
37751   private boolean jj_3R_598() {
37752     if (jj_scan_token(9)) return true;
37753     if (jj_scan_token(10)) return true;
37754     return false;
37755   }
37756 
37757   private boolean jj_3_57() {
37758     Token xsp;
37759     if (jj_scan_token(5)) return true;
37760     while (true) {
37761       xsp = jj_scanpos;
37762       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37763     }
37764     if (jj_scan_token(WITH)) return true;
37765     return false;
37766   }
37767 
37768   private boolean jj_3R_561() {
37769     Token xsp;
37770     xsp = jj_scanpos;
37771     if (jj_3R_598()) {
37772     jj_scanpos = xsp;
37773     if (jj_scan_token(92)) return true;
37774     }
37775     if (jj_3R_234()) return true;
37776     return false;
37777   }
37778 
37779   private boolean jj_3_56() {
37780     if (jj_scan_token(WITH)) return true;
37781     return false;
37782   }
37783 
37784   private boolean jj_3_55() {
37785     Token xsp;
37786     if (jj_scan_token(5)) return true;
37787     while (true) {
37788       xsp = jj_scanpos;
37789       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37790     }
37791     if (jj_scan_token(SELECT)) return true;
37792     return false;
37793   }
37794 
37795   private boolean jj_3_25() {
37796     Token xsp;
37797     xsp = jj_scanpos;
37798     if (jj_3_24()) {
37799     jj_scanpos = xsp;
37800     if (jj_scan_token(137)) return true;
37801     }
37802     return false;
37803   }
37804 
37805   private boolean jj_3_54() {
37806     if (jj_scan_token(SELECT)) return true;
37807     return false;
37808   }
37809 
37810   private boolean jj_3R_296() {
37811     if (jj_scan_token(6)) return true;
37812     if (jj_3R_234()) return true;
37813     return false;
37814   }
37815 
37816   private boolean jj_3_53() {
37817     if (jj_3R_140()) return true;
37818     return false;
37819   }
37820 
37821   private boolean jj_3R_600() {
37822     if (jj_scan_token(3)) return true;
37823     if (jj_3R_124()) return true;
37824     return false;
37825   }
37826 
37827   private boolean jj_3_52() {
37828     if (jj_3R_139()) return true;
37829     return false;
37830   }
37831 
37832   private boolean jj_3R_517() {
37833     if (jj_3R_124()) return true;
37834     return false;
37835   }
37836 
37837   private boolean jj_3R_462() {
37838     if (jj_3R_174()) return true;
37839     return false;
37840   }
37841 
37842   private boolean jj_3R_222() {
37843     if (jj_scan_token(5)) return true;
37844     if (jj_3R_234()) return true;
37845     Token xsp;
37846     while (true) {
37847       xsp = jj_scanpos;
37848       if (jj_3R_296()) { jj_scanpos = xsp; break; }
37849     }
37850     if (jj_scan_token(7)) return true;
37851     return false;
37852   }
37853 
37854   private boolean jj_3_51() {
37855     if (jj_3R_138()) return true;
37856     return false;
37857   }
37858 
37859   private boolean jj_3R_461() {
37860     if (jj_3R_423()) return true;
37861     return false;
37862   }
37863 
37864   private boolean jj_3R_388() {
37865     if (jj_scan_token(USING)) return true;
37866     if (jj_3R_124()) return true;
37867     Token xsp;
37868     xsp = jj_scanpos;
37869     if (jj_3R_487()) jj_scanpos = xsp;
37870     return false;
37871   }
37872 
37873   private boolean jj_3_50() {
37874     if (jj_3R_137()) return true;
37875     return false;
37876   }
37877 
37878   private boolean jj_3R_221() {
37879     if (jj_scan_token(5)) return true;
37880     if (jj_3R_180()) return true;
37881     if (jj_scan_token(7)) return true;
37882     return false;
37883   }
37884 
37885   private boolean jj_3R_220() {
37886     if (jj_scan_token(WITH)) return true;
37887     if (jj_3R_180()) return true;
37888     return false;
37889   }
37890 
37891   private boolean jj_3R_219() {
37892     if (jj_scan_token(5)) return true;
37893     if (jj_3R_180()) return true;
37894     if (jj_scan_token(7)) return true;
37895     return false;
37896   }
37897 
37898   private boolean jj_3R_475() {
37899     if (jj_3R_124()) return true;
37900     Token xsp;
37901     xsp = jj_scanpos;
37902     if (jj_3_25()) jj_scanpos = xsp;
37903     xsp = jj_scanpos;
37904     if (jj_scan_token(8)) {
37905     jj_scanpos = xsp;
37906     if (jj_3R_560()) return true;
37907     }
37908     xsp = jj_scanpos;
37909     if (jj_3R_561()) jj_scanpos = xsp;
37910     return false;
37911   }
37912 
37913   private boolean jj_3R_218() {
37914     if (jj_scan_token(SELECT)) return true;
37915     if (jj_3R_180()) return true;
37916     return false;
37917   }
37918 
37919   private boolean jj_3R_217() {
37920     if (jj_3R_295()) return true;
37921     return false;
37922   }
37923 
37924   private boolean jj_3R_216() {
37925     if (jj_3R_140()) return true;
37926     return false;
37927   }
37928 
37929   private boolean jj_3R_215() {
37930     if (jj_3R_139()) return true;
37931     return false;
37932   }
37933 
37934   private boolean jj_3R_214() {
37935     if (jj_3R_138()) return true;
37936     return false;
37937   }
37938 
37939   private boolean jj_3R_213() {
37940     if (jj_3R_137()) return true;
37941     return false;
37942   }
37943 
37944   private boolean jj_3R_516() {
37945     if (jj_scan_token(3)) return true;
37946     if (jj_3R_124()) return true;
37947     return false;
37948   }
37949 
37950   private boolean jj_3R_212() {
37951     if (jj_3R_294()) return true;
37952     return false;
37953   }
37954 
37955   private boolean jj_3R_332() {
37956     if (jj_3R_192()) return true;
37957     if (jj_scan_token(BEGIN)) return true;
37958     Token xsp;
37959     xsp = jj_scanpos;
37960     if (jj_3R_461()) jj_scanpos = xsp;
37961     while (true) {
37962       xsp = jj_scanpos;
37963       if (jj_3R_462()) { jj_scanpos = xsp; break; }
37964     }
37965     xsp = jj_scanpos;
37966     if (jj_3R_463()) jj_scanpos = xsp;
37967     if (jj_scan_token(END)) return true;
37968     xsp = jj_scanpos;
37969     if (jj_3R_464()) jj_scanpos = xsp;
37970     return false;
37971   }
37972 
37973   private boolean jj_3_22() {
37974     if (jj_3R_124()) return true;
37975     if (jj_scan_token(3)) return true;
37976     return false;
37977   }
37978 
37979   private boolean jj_3R_135() {
37980     Token xsp;
37981     xsp = jj_scanpos;
37982     if (jj_3R_212()) {
37983     jj_scanpos = xsp;
37984     if (jj_3R_213()) {
37985     jj_scanpos = xsp;
37986     if (jj_3R_214()) {
37987     jj_scanpos = xsp;
37988     if (jj_3R_215()) {
37989     jj_scanpos = xsp;
37990     if (jj_3R_216()) {
37991     jj_scanpos = xsp;
37992     if (jj_3R_217()) {
37993     jj_scanpos = xsp;
37994     if (jj_3R_218()) {
37995     jj_scanpos = xsp;
37996     if (jj_3R_219()) {
37997     jj_scanpos = xsp;
37998     if (jj_3R_220()) {
37999     jj_scanpos = xsp;
38000     if (jj_3R_221()) {
38001     jj_scanpos = xsp;
38002     if (jj_3R_222()) return true;
38003     }
38004     }
38005     }
38006     }
38007     }
38008     }
38009     }
38010     }
38011     }
38012     }
38013     return false;
38014   }
38015 
38016   private boolean jj_3_21() {
38017     if (jj_3R_123()) return true;
38018     return false;
38019   }
38020 
38021   private boolean jj_3_49() {
38022     if (jj_3R_136()) return true;
38023     return false;
38024   }
38025 
38026   private boolean jj_3_48() {
38027     if (jj_scan_token(NEW)) return true;
38028     if (jj_3R_135()) return true;
38029     return false;
38030   }
38031 
38032   private boolean jj_3R_155() {
38033     Token xsp;
38034     xsp = jj_scanpos;
38035     if (jj_3_22()) jj_scanpos = xsp;
38036     if (jj_3R_124()) return true;
38037     return false;
38038   }
38039 
38040   private boolean jj_3R_293() {
38041     if (jj_3R_135()) return true;
38042     return false;
38043   }
38044 
38045   private boolean jj_3R_390() {
38046     if (jj_scan_token(RELIES_ON)) return true;
38047     if (jj_scan_token(5)) return true;
38048     if (jj_3R_124()) return true;
38049     Token xsp;
38050     xsp = jj_scanpos;
38051     if (jj_3R_600()) jj_scanpos = xsp;
38052     while (true) {
38053       xsp = jj_scanpos;
38054       if (jj_3R_601()) { jj_scanpos = xsp; break; }
38055     }
38056     if (jj_scan_token(7)) return true;
38057     return false;
38058   }
38059 
38060   private boolean jj_3R_387() {
38061     if (jj_3R_429()) return true;
38062     return false;
38063   }
38064 
38065   private boolean jj_3R_431() {
38066     Token xsp;
38067     xsp = jj_scanpos;
38068     if (jj_scan_token(204)) {
38069     jj_scanpos = xsp;
38070     if (jj_scan_token(71)) return true;
38071     }
38072     xsp = jj_scanpos;
38073     if (jj_3R_517()) jj_scanpos = xsp;
38074     if (jj_scan_token(BY)) return true;
38075     if (jj_scan_token(5)) return true;
38076     if (jj_3R_124()) return true;
38077     while (true) {
38078       xsp = jj_scanpos;
38079       if (jj_3R_624()) { jj_scanpos = xsp; break; }
38080     }
38081     if (jj_scan_token(7)) return true;
38082     return false;
38083   }
38084 
38085   private boolean jj_3R_282() {
38086     Token xsp;
38087     xsp = jj_scanpos;
38088     if (jj_scan_token(152)) {
38089     jj_scanpos = xsp;
38090     if (jj_scan_token(51)) return true;
38091     }
38092     xsp = jj_scanpos;
38093     if (jj_3_21()) {
38094     jj_scanpos = xsp;
38095     if (jj_3R_332()) return true;
38096     }
38097     return false;
38098   }
38099 
38100   private boolean jj_3R_292() {
38101     if (jj_scan_token(NEW)) return true;
38102     if (jj_3R_135()) return true;
38103     return false;
38104   }
38105 
38106   private boolean jj_3R_430() {
38107     if (jj_scan_token(USING)) return true;
38108     if (jj_3R_124()) return true;
38109     Token xsp;
38110     xsp = jj_scanpos;
38111     if (jj_3R_516()) jj_scanpos = xsp;
38112     return false;
38113   }
38114 
38115   private boolean jj_3R_389() {
38116     Token xsp;
38117     xsp = jj_scanpos;
38118     if (jj_3R_430()) {
38119     jj_scanpos = xsp;
38120     if (jj_3R_431()) return true;
38121     }
38122     return false;
38123   }
38124 
38125   private boolean jj_3R_637() {
38126     if (jj_scan_token(6)) return true;
38127     Token xsp;
38128     xsp = jj_scanpos;
38129     if (jj_scan_token(198)) jj_scanpos = xsp;
38130     if (jj_3R_295()) return true;
38131     return false;
38132   }
38133 
38134   private boolean jj_3R_211() {
38135     Token xsp;
38136     xsp = jj_scanpos;
38137     if (jj_3R_292()) {
38138     jj_scanpos = xsp;
38139     if (jj_3R_293()) return true;
38140     }
38141     while (true) {
38142       xsp = jj_scanpos;
38143       if (jj_3_49()) { jj_scanpos = xsp; break; }
38144     }
38145     return false;
38146   }
38147 
38148   private boolean jj_3R_277() {
38149     Token xsp;
38150     xsp = jj_scanpos;
38151     if (jj_scan_token(100)) {
38152     jj_scanpos = xsp;
38153     if (jj_scan_token(182)) return true;
38154     }
38155     return false;
38156   }
38157 
38158   private boolean jj_3R_210() {
38159     if (jj_scan_token(NEW_DOT)) return true;
38160     if (jj_3R_120()) return true;
38161     return false;
38162   }
38163 
38164   private boolean jj_3R_133() {
38165     Token xsp;
38166     xsp = jj_scanpos;
38167     if (jj_3R_210()) {
38168     jj_scanpos = xsp;
38169     if (jj_3R_211()) return true;
38170     }
38171     return false;
38172   }
38173 
38174   private boolean jj_3R_281() {
38175     if (jj_scan_token(AGGREGATE)) return true;
38176     if (jj_scan_token(USING)) return true;
38177     if (jj_3R_124()) return true;
38178     return false;
38179   }
38180 
38181   private boolean jj_3R_331() {
38182     if (jj_scan_token(RESULT_CACHE)) return true;
38183     Token xsp;
38184     xsp = jj_scanpos;
38185     if (jj_3R_390()) jj_scanpos = xsp;
38186     return false;
38187   }
38188 
38189   private boolean jj_3R_330() {
38190     if (jj_scan_token(PIPELINED)) return true;
38191     Token xsp;
38192     xsp = jj_scanpos;
38193     if (jj_3R_389()) jj_scanpos = xsp;
38194     return false;
38195   }
38196 
38197   private boolean jj_3R_329() {
38198     if (jj_scan_token(PARALLEL_ENABLE)) return true;
38199     Token xsp;
38200     xsp = jj_scanpos;
38201     if (jj_3R_387()) jj_scanpos = xsp;
38202     xsp = jj_scanpos;
38203     if (jj_3R_388()) jj_scanpos = xsp;
38204     return false;
38205   }
38206 
38207   private boolean jj_3R_328() {
38208     if (jj_3R_239()) return true;
38209     return false;
38210   }
38211 
38212   private boolean jj_3_47() {
38213     if (jj_scan_token(IDENTIFIER)) return true;
38214     if (jj_scan_token(IS)) return true;
38215     return false;
38216   }
38217 
38218   private boolean jj_3R_280() {
38219     Token xsp;
38220     xsp = jj_scanpos;
38221     if (jj_3R_327()) {
38222     jj_scanpos = xsp;
38223     if (jj_scan_token(95)) {
38224     jj_scanpos = xsp;
38225     if (jj_3R_328()) {
38226     jj_scanpos = xsp;
38227     if (jj_3R_329()) {
38228     jj_scanpos = xsp;
38229     if (jj_3R_330()) {
38230     jj_scanpos = xsp;
38231     if (jj_3R_331()) return true;
38232     }
38233     }
38234     }
38235     }
38236     }
38237     return false;
38238   }
38239 
38240   private boolean jj_3R_327() {
38241     if (jj_scan_token(AUTHID)) return true;
38242     Token xsp;
38243     xsp = jj_scanpos;
38244     if (jj_scan_token(37)) {
38245     jj_scanpos = xsp;
38246     if (jj_scan_token(36)) return true;
38247     }
38248     return false;
38249   }
38250 
38251   private boolean jj_3R_134() {
38252     if (jj_scan_token(NOT)) return true;
38253     if (jj_scan_token(NULL)) return true;
38254     return false;
38255   }
38256 
38257   private boolean jj_3R_196() {
38258     Token xsp;
38259     while (true) {
38260       xsp = jj_scanpos;
38261       if (jj_3R_280()) { jj_scanpos = xsp; break; }
38262     }
38263     xsp = jj_scanpos;
38264     if (jj_3R_281()) jj_scanpos = xsp;
38265     xsp = jj_scanpos;
38266     if (jj_3R_282()) jj_scanpos = xsp;
38267     if (jj_scan_token(4)) return true;
38268     return false;
38269   }
38270 
38271   private boolean jj_3R_635() {
38272     if (jj_3R_133()) return true;
38273     return false;
38274   }
38275 
38276   private boolean jj_3R_276() {
38277     if (jj_scan_token(OR)) return true;
38278     if (jj_scan_token(REPLACE)) return true;
38279     return false;
38280   }
38281 
38282   private boolean jj_3R_634() {
38283     if (jj_3R_295()) return true;
38284     if (jj_scan_token(IS)) return true;
38285     Token xsp;
38286     xsp = jj_scanpos;
38287     if (jj_3R_636()) jj_scanpos = xsp;
38288     if (jj_scan_token(OF)) return true;
38289     xsp = jj_scanpos;
38290     if (jj_scan_token(284)) jj_scanpos = xsp;
38291     if (jj_scan_token(5)) return true;
38292     xsp = jj_scanpos;
38293     if (jj_scan_token(198)) jj_scanpos = xsp;
38294     if (jj_3R_295()) return true;
38295     while (true) {
38296       xsp = jj_scanpos;
38297       if (jj_3R_637()) { jj_scanpos = xsp; break; }
38298     }
38299     if (jj_scan_token(7)) return true;
38300     return false;
38301   }
38302 
38303   private boolean jj_3R_195() {
38304     if (jj_3R_249()) return true;
38305     return false;
38306   }
38307 
38308   private boolean jj_3R_632() {
38309     Token xsp;
38310     xsp = jj_scanpos;
38311     if (jj_3R_634()) {
38312     jj_scanpos = xsp;
38313     if (jj_3R_635()) return true;
38314     }
38315     return false;
38316   }
38317 
38318   private boolean jj_3R_193() {
38319     if (jj_scan_token(CREATE)) return true;
38320     Token xsp;
38321     xsp = jj_scanpos;
38322     if (jj_3R_276()) jj_scanpos = xsp;
38323     xsp = jj_scanpos;
38324     if (jj_3R_277()) jj_scanpos = xsp;
38325     return false;
38326   }
38327 
38328   private boolean jj_3R_118() {
38329     Token xsp;
38330     xsp = jj_scanpos;
38331     if (jj_3R_193()) jj_scanpos = xsp;
38332     if (jj_3R_194()) return true;
38333     xsp = jj_scanpos;
38334     if (jj_3R_195()) {
38335     jj_scanpos = xsp;
38336     if (jj_3R_196()) return true;
38337     }
38338     return false;
38339   }
38340 
38341   private boolean jj_3_46() {
38342     if (jj_scan_token(IDENTIFIER)) return true;
38343     if (jj_scan_token(IS)) return true;
38344     Token xsp;
38345     xsp = jj_scanpos;
38346     if (jj_3R_134()) {
38347     jj_scanpos = xsp;
38348     if (jj_scan_token(185)) return true;
38349     }
38350     return false;
38351   }
38352 
38353   private boolean jj_3R_627() {
38354     if (jj_3R_632()) return true;
38355     return false;
38356   }
38357 
38358   private boolean jj_3R_626() {
38359     if (jj_3R_295()) return true;
38360     if (jj_scan_token(IS)) return true;
38361     Token xsp;
38362     xsp = jj_scanpos;
38363     if (jj_3R_631()) jj_scanpos = xsp;
38364     if (jj_scan_token(NULL)) return true;
38365     return false;
38366   }
38367 
38368   private boolean jj_3R_535() {
38369     if (jj_scan_token(CC_ERROR)) return true;
38370     if (jj_3R_234()) return true;
38371     if (jj_scan_token(CC_END)) return true;
38372     return false;
38373   }
38374 
38375   private boolean jj_3R_615() {
38376     Token xsp;
38377     xsp = jj_scanpos;
38378     if (jj_3R_626()) {
38379     jj_scanpos = xsp;
38380     if (jj_3R_627()) return true;
38381     }
38382     return false;
38383   }
38384 
38385   private boolean jj_3R_534() {
38386     if (jj_3R_323()) return true;
38387     return false;
38388   }
38389 
38390   private boolean jj_3R_506() {
38391     Token xsp;
38392     xsp = jj_scanpos;
38393     if (jj_3R_534()) {
38394     jj_scanpos = xsp;
38395     if (jj_3R_535()) return true;
38396     }
38397     return false;
38398   }
38399 
38400   private boolean jj_3R_474() {
38401     if (jj_scan_token(CC_ELSE)) return true;
38402     Token xsp;
38403     while (true) {
38404       xsp = jj_scanpos;
38405       if (jj_3R_506()) { jj_scanpos = xsp; break; }
38406     }
38407     return false;
38408   }
38409 
38410   private boolean jj_3R_533() {
38411     if (jj_scan_token(CC_ERROR)) return true;
38412     if (jj_3R_234()) return true;
38413     if (jj_scan_token(CC_END)) return true;
38414     return false;
38415   }
38416 
38417   private boolean jj_3R_532() {
38418     if (jj_3R_323()) return true;
38419     return false;
38420   }
38421 
38422   private boolean jj_3R_505() {
38423     Token xsp;
38424     xsp = jj_scanpos;
38425     if (jj_3R_532()) {
38426     jj_scanpos = xsp;
38427     if (jj_3R_533()) return true;
38428     }
38429     return false;
38430   }
38431 
38432   private boolean jj_3R_590() {
38433     if (jj_3R_615()) return true;
38434     return false;
38435   }
38436 
38437   private boolean jj_3R_473() {
38438     if (jj_scan_token(CC_ELSIF)) return true;
38439     if (jj_3R_344()) return true;
38440     if (jj_scan_token(CC_THEN)) return true;
38441     Token xsp;
38442     while (true) {
38443       xsp = jj_scanpos;
38444       if (jj_3R_505()) { jj_scanpos = xsp; break; }
38445     }
38446     return false;
38447   }
38448 
38449   private boolean jj_3R_589() {
38450     if (jj_scan_token(NOT)) return true;
38451     if (jj_3R_484()) return true;
38452     return false;
38453   }
38454 
38455   private boolean jj_3R_504() {
38456     if (jj_scan_token(CC_ERROR)) return true;
38457     if (jj_3R_234()) return true;
38458     if (jj_scan_token(CC_END)) return true;
38459     return false;
38460   }
38461 
38462   private boolean jj_3R_254() {
38463     if (jj_3R_124()) return true;
38464     return false;
38465   }
38466 
38467   private boolean jj_3R_545() {
38468     Token xsp;
38469     xsp = jj_scanpos;
38470     if (jj_3R_589()) {
38471     jj_scanpos = xsp;
38472     if (jj_3R_590()) return true;
38473     }
38474     return false;
38475   }
38476 
38477   private boolean jj_3R_503() {
38478     if (jj_3R_323()) return true;
38479     return false;
38480   }
38481 
38482   private boolean jj_3R_472() {
38483     Token xsp;
38484     xsp = jj_scanpos;
38485     if (jj_3R_503()) {
38486     jj_scanpos = xsp;
38487     if (jj_3R_504()) return true;
38488     }
38489     return false;
38490   }
38491 
38492   private boolean jj_3R_514() {
38493     if (jj_3R_545()) return true;
38494     return false;
38495   }
38496 
38497   private boolean jj_3R_544() {
38498     if (jj_scan_token(17)) return true;
38499     return false;
38500   }
38501 
38502   private boolean jj_3R_427() {
38503     if (jj_scan_token(CC_IF)) return true;
38504     if (jj_3R_344()) return true;
38505     if (jj_scan_token(CC_THEN)) return true;
38506     Token xsp;
38507     while (true) {
38508       xsp = jj_scanpos;
38509       if (jj_3R_472()) { jj_scanpos = xsp; break; }
38510     }
38511     while (true) {
38512       xsp = jj_scanpos;
38513       if (jj_3R_473()) { jj_scanpos = xsp; break; }
38514     }
38515     while (true) {
38516       xsp = jj_scanpos;
38517       if (jj_3R_474()) { jj_scanpos = xsp; break; }
38518     }
38519     if (jj_scan_token(CC_END)) return true;
38520     return false;
38521   }
38522 
38523   private boolean jj_3R_543() {
38524     if (jj_scan_token(16)) return true;
38525     return false;
38526   }
38527 
38528   private boolean jj_3R_275() {
38529     if (jj_3R_323()) return true;
38530     return false;
38531   }
38532 
38533   private boolean jj_3R_513() {
38534     Token xsp;
38535     xsp = jj_scanpos;
38536     if (jj_3R_543()) {
38537     jj_scanpos = xsp;
38538     if (jj_3R_544()) return true;
38539     }
38540     if (jj_3R_484()) return true;
38541     return false;
38542   }
38543 
38544   private boolean jj_3R_484() {
38545     Token xsp;
38546     xsp = jj_scanpos;
38547     if (jj_3R_513()) {
38548     jj_scanpos = xsp;
38549     if (jj_3R_514()) return true;
38550     }
38551     return false;
38552   }
38553 
38554   private boolean jj_3R_385() {
38555     if (jj_3R_427()) return true;
38556     return false;
38557   }
38558 
38559   private boolean jj_3R_192() {
38560     Token xsp;
38561     while (true) {
38562       xsp = jj_scanpos;
38563       if (jj_3R_275()) { jj_scanpos = xsp; break; }
38564     }
38565     return false;
38566   }
38567 
38568   private boolean jj_3R_384() {
38569     if (jj_3R_426()) return true;
38570     return false;
38571   }
38572 
38573   private boolean jj_3_18() {
38574     Token xsp;
38575     xsp = jj_scanpos;
38576     if (jj_scan_token(125)) {
38577     jj_scanpos = xsp;
38578     if (jj_scan_token(223)) return true;
38579     }
38580     if (jj_3R_120()) return true;
38581     return false;
38582   }
38583 
38584   private boolean jj_3_17() {
38585     Token xsp;
38586     xsp = jj_scanpos;
38587     if (jj_scan_token(284)) {
38588     jj_scanpos = xsp;
38589     if (jj_scan_token(264)) return true;
38590     }
38591     if (jj_3R_120()) return true;
38592     xsp = jj_scanpos;
38593     if (jj_scan_token(152)) {
38594     jj_scanpos = xsp;
38595     if (jj_scan_token(51)) return true;
38596     }
38597     return false;
38598   }
38599 
38600   private boolean jj_3R_608() {
38601     if (jj_scan_token(MOD)) return true;
38602     return false;
38603   }
38604 
38605   private boolean jj_3R_383() {
38606     if (jj_3R_425()) return true;
38607     return false;
38608   }
38609 
38610   private boolean jj_3R_607() {
38611     if (jj_scan_token(1)) return true;
38612     return false;
38613   }
38614 
38615   private boolean jj_3R_382() {
38616     if (jj_3R_424()) return true;
38617     return false;
38618   }
38619 
38620   private boolean jj_3R_606() {
38621     if (jj_scan_token(20)) return true;
38622     return false;
38623   }
38624 
38625   private boolean jj_3R_605() {
38626     if (jj_scan_token(19)) return true;
38627     return false;
38628   }
38629 
38630   private boolean jj_3_20() {
38631     if (jj_3R_122()) return true;
38632     return false;
38633   }
38634 
38635   private boolean jj_3R_307() {
38636     if (jj_3R_351()) return true;
38637     return false;
38638   }
38639 
38640   private boolean jj_3R_570() {
38641     Token xsp;
38642     xsp = jj_scanpos;
38643     if (jj_3R_605()) {
38644     jj_scanpos = xsp;
38645     if (jj_3R_606()) {
38646     jj_scanpos = xsp;
38647     if (jj_3R_607()) {
38648     jj_scanpos = xsp;
38649     if (jj_3R_608()) return true;
38650     }
38651     }
38652     }
38653     if (jj_3R_484()) return true;
38654     return false;
38655   }
38656 
38657   private boolean jj_3_19() {
38658     if (jj_3R_121()) return true;
38659     return false;
38660   }
38661 
38662   private boolean jj_3R_381() {
38663     if (jj_3R_118()) return true;
38664     return false;
38665   }
38666 
38667   private boolean jj_3R_380() {
38668     if (jj_3R_153()) return true;
38669     return false;
38670   }
38671 
38672   private boolean jj_3_16() {
38673     if (jj_3R_119()) return true;
38674     return false;
38675   }
38676 
38677   private boolean jj_3R_379() {
38678     if (jj_3R_423()) return true;
38679     return false;
38680   }
38681 
38682   private boolean jj_3R_537() {
38683     if (jj_3R_484()) return true;
38684     Token xsp;
38685     while (true) {
38686       xsp = jj_scanpos;
38687       if (jj_3R_570()) { jj_scanpos = xsp; break; }
38688     }
38689     return false;
38690   }
38691 
38692   private boolean jj_3_15() {
38693     if (jj_3R_118()) return true;
38694     return false;
38695   }
38696 
38697   private boolean jj_3R_252() {
38698     Token xsp;
38699     xsp = jj_scanpos;
38700     if (jj_scan_token(100)) {
38701     jj_scanpos = xsp;
38702     if (jj_scan_token(182)) return true;
38703     }
38704     return false;
38705   }
38706 
38707   private boolean jj_3R_306() {
38708     if (jj_3R_174()) return true;
38709     return false;
38710   }
38711 
38712   private boolean jj_3R_300() {
38713     if (jj_scan_token(18)) return true;
38714     if (jj_3R_133()) return true;
38715     return false;
38716   }
38717 
38718   private boolean jj_3R_323() {
38719     Token xsp;
38720     xsp = jj_scanpos;
38721     if (jj_3R_379()) {
38722     jj_scanpos = xsp;
38723     if (jj_3_16()) {
38724     jj_scanpos = xsp;
38725     if (jj_3R_380()) {
38726     jj_scanpos = xsp;
38727     if (jj_3R_381()) {
38728     jj_scanpos = xsp;
38729     if (jj_3_19()) {
38730     jj_scanpos = xsp;
38731     if (jj_3_20()) {
38732     jj_scanpos = xsp;
38733     if (jj_3R_382()) {
38734     jj_scanpos = xsp;
38735     if (jj_3R_383()) {
38736     jj_scanpos = xsp;
38737     if (jj_3R_384()) {
38738     jj_scanpos = xsp;
38739     if (jj_3R_385()) return true;
38740     }
38741     }
38742     }
38743     }
38744     }
38745     }
38746     }
38747     }
38748     }
38749     return false;
38750   }
38751 
38752   private boolean jj_3R_253() {
38753     if (jj_scan_token(BEGIN)) return true;
38754     Token xsp;
38755     while (true) {
38756       xsp = jj_scanpos;
38757       if (jj_3R_306()) { jj_scanpos = xsp; break; }
38758     }
38759     xsp = jj_scanpos;
38760     if (jj_3R_307()) jj_scanpos = xsp;
38761     return false;
38762   }
38763 
38764   private boolean jj_3R_230() {
38765     if (jj_3R_133()) return true;
38766     Token xsp;
38767     while (true) {
38768       xsp = jj_scanpos;
38769       if (jj_3R_300()) { jj_scanpos = xsp; break; }
38770     }
38771     return false;
38772   }
38773 
38774   private boolean jj_3R_251() {
38775     if (jj_scan_token(OR)) return true;
38776     if (jj_scan_token(REPLACE)) return true;
38777     return false;
38778   }
38779 
38780   private boolean jj_3R_573() {
38781     if (jj_scan_token(18)) return true;
38782     return false;
38783   }
38784 
38785   private boolean jj_3R_161() {
38786     Token xsp;
38787     xsp = jj_scanpos;
38788     if (jj_scan_token(152)) {
38789     jj_scanpos = xsp;
38790     if (jj_scan_token(51)) return true;
38791     }
38792     if (jj_3R_192()) return true;
38793     xsp = jj_scanpos;
38794     if (jj_3R_253()) jj_scanpos = xsp;
38795     if (jj_scan_token(END)) return true;
38796     xsp = jj_scanpos;
38797     if (jj_3R_254()) jj_scanpos = xsp;
38798     if (jj_scan_token(4)) return true;
38799     return false;
38800   }
38801 
38802   private boolean jj_3R_572() {
38803     if (jj_scan_token(17)) return true;
38804     return false;
38805   }
38806 
38807   private boolean jj_3R_571() {
38808     if (jj_scan_token(16)) return true;
38809     return false;
38810   }
38811 
38812   private boolean jj_3R_538() {
38813     Token xsp;
38814     xsp = jj_scanpos;
38815     if (jj_3R_571()) {
38816     jj_scanpos = xsp;
38817     if (jj_3R_572()) {
38818     jj_scanpos = xsp;
38819     if (jj_3R_573()) return true;
38820     }
38821     }
38822     if (jj_3R_537()) return true;
38823     return false;
38824   }
38825 
38826   private boolean jj_3R_160() {
38827     if (jj_3R_249()) return true;
38828     return false;
38829   }
38830 
38831   private boolean jj_3R_271() {
38832     if (jj_3R_191()) return true;
38833     return false;
38834   }
38835 
38836   private boolean jj_3R_159() {
38837     if (jj_scan_token(CREATE)) return true;
38838     Token xsp;
38839     xsp = jj_scanpos;
38840     if (jj_3R_251()) jj_scanpos = xsp;
38841     xsp = jj_scanpos;
38842     if (jj_3R_252()) jj_scanpos = xsp;
38843     return false;
38844   }
38845 
38846   private boolean jj_3R_508() {
38847     if (jj_3R_537()) return true;
38848     Token xsp;
38849     while (true) {
38850       xsp = jj_scanpos;
38851       if (jj_3R_538()) { jj_scanpos = xsp; break; }
38852     }
38853     return false;
38854   }
38855 
38856   private boolean jj_3R_588() {
38857     if (jj_3R_183()) return true;
38858     return false;
38859   }
38860 
38861   private boolean jj_3R_246() {
38862     Token xsp;
38863     xsp = jj_scanpos;
38864     if (jj_scan_token(100)) {
38865     jj_scanpos = xsp;
38866     if (jj_scan_token(182)) return true;
38867     }
38868     return false;
38869   }
38870 
38871   private boolean jj_3R_250() {
38872     if (jj_3R_124()) return true;
38873     return false;
38874   }
38875 
38876   private boolean jj_3R_202() {
38877     if (jj_3R_283()) return true;
38878     return false;
38879   }
38880 
38881   private boolean jj_3R_587() {
38882     if (jj_scan_token(CHARACTER_LITERAL)) return true;
38883     return false;
38884   }
38885 
38886   private boolean jj_3R_104() {
38887     Token xsp;
38888     xsp = jj_scanpos;
38889     if (jj_3R_159()) jj_scanpos = xsp;
38890     xsp = jj_scanpos;
38891     if (jj_scan_token(209)) {
38892     jj_scanpos = xsp;
38893     if (jj_scan_token(284)) return true;
38894     }
38895     if (jj_scan_token(BODY)) return true;
38896     if (jj_3R_155()) return true;
38897     xsp = jj_scanpos;
38898     if (jj_3R_160()) {
38899     jj_scanpos = xsp;
38900     if (jj_3R_161()) return true;
38901     }
38902     return false;
38903   }
38904 
38905   private boolean jj_3R_542() {
38906     if (jj_scan_token(ESCAPE)) return true;
38907     Token xsp;
38908     xsp = jj_scanpos;
38909     if (jj_3R_587()) {
38910     jj_scanpos = xsp;
38911     if (jj_3R_588()) return true;
38912     }
38913     return false;
38914   }
38915 
38916   private boolean jj_3R_614() {
38917     if (jj_scan_token(ALL)) return true;
38918     return false;
38919   }
38920 
38921   private boolean jj_3R_613() {
38922     if (jj_scan_token(DISTINCT)) return true;
38923     return false;
38924   }
38925 
38926   private boolean jj_3R_586() {
38927     Token xsp;
38928     xsp = jj_scanpos;
38929     if (jj_3R_613()) {
38930     jj_scanpos = xsp;
38931     if (jj_3R_614()) return true;
38932     }
38933     return false;
38934   }
38935 
38936   private boolean jj_3R_585() {
38937     if (jj_scan_token(UNION)) return true;
38938     return false;
38939   }
38940 
38941   private boolean jj_3R_584() {
38942     if (jj_scan_token(INTERSECT)) return true;
38943     return false;
38944   }
38945 
38946   private boolean jj_3R_124() {
38947     Token xsp;
38948     xsp = jj_scanpos;
38949     if (jj_scan_token(420)) {
38950     jj_scanpos = xsp;
38951     if (jj_scan_token(428)) {
38952     jj_scanpos = xsp;
38953     if (jj_3R_202()) {
38954     jj_scanpos = xsp;
38955     if (jj_scan_token(35)) {
38956     jj_scanpos = xsp;
38957     if (jj_scan_token(38)) {
38958     jj_scanpos = xsp;
38959     if (jj_scan_token(39)) {
38960     jj_scanpos = xsp;
38961     if (jj_scan_token(40)) {
38962     jj_scanpos = xsp;
38963     if (jj_scan_token(41)) {
38964     jj_scanpos = xsp;
38965     if (jj_scan_token(46)) {
38966     jj_scanpos = xsp;
38967     if (jj_scan_token(47)) {
38968     jj_scanpos = xsp;
38969     if (jj_scan_token(48)) {
38970     jj_scanpos = xsp;
38971     if (jj_scan_token(49)) {
38972     jj_scanpos = xsp;
38973     if (jj_scan_token(50)) {
38974     jj_scanpos = xsp;
38975     if (jj_scan_token(51)) {
38976     jj_scanpos = xsp;
38977     if (jj_scan_token(52)) {
38978     jj_scanpos = xsp;
38979     if (jj_scan_token(56)) {
38980     jj_scanpos = xsp;
38981     if (jj_scan_token(58)) {
38982     jj_scanpos = xsp;
38983     if (jj_scan_token(59)) {
38984     jj_scanpos = xsp;
38985     if (jj_scan_token(60)) {
38986     jj_scanpos = xsp;
38987     if (jj_scan_token(61)) {
38988     jj_scanpos = xsp;
38989     if (jj_scan_token(63)) {
38990     jj_scanpos = xsp;
38991     if (jj_scan_token(66)) {
38992     jj_scanpos = xsp;
38993     if (jj_scan_token(67)) {
38994     jj_scanpos = xsp;
38995     if (jj_scan_token(68)) {
38996     jj_scanpos = xsp;
38997     if (jj_scan_token(69)) {
38998     jj_scanpos = xsp;
38999     if (jj_scan_token(71)) {
39000     jj_scanpos = xsp;
39001     if (jj_scan_token(77)) {
39002     jj_scanpos = xsp;
39003     if (jj_scan_token(78)) {
39004     jj_scanpos = xsp;
39005     if (jj_scan_token(79)) {
39006     jj_scanpos = xsp;
39007     if (jj_scan_token(83)) {
39008     jj_scanpos = xsp;
39009     if (jj_scan_token(85)) {
39010     jj_scanpos = xsp;
39011     if (jj_scan_token(88)) {
39012     jj_scanpos = xsp;
39013     if (jj_scan_token(90)) {
39014     jj_scanpos = xsp;
39015     if (jj_scan_token(91)) {
39016     jj_scanpos = xsp;
39017     if (jj_scan_token(92)) {
39018     jj_scanpos = xsp;
39019     if (jj_scan_token(93)) {
39020     jj_scanpos = xsp;
39021     if (jj_scan_token(94)) {
39022     jj_scanpos = xsp;
39023     if (jj_scan_token(97)) {
39024     jj_scanpos = xsp;
39025     if (jj_scan_token(98)) {
39026     jj_scanpos = xsp;
39027     if (jj_scan_token(99)) {
39028     jj_scanpos = xsp;
39029     if (jj_scan_token(102)) {
39030     jj_scanpos = xsp;
39031     if (jj_scan_token(103)) {
39032     jj_scanpos = xsp;
39033     if (jj_scan_token(108)) {
39034     jj_scanpos = xsp;
39035     if (jj_scan_token(110)) {
39036     jj_scanpos = xsp;
39037     if (jj_scan_token(111)) {
39038     jj_scanpos = xsp;
39039     if (jj_scan_token(112)) {
39040     jj_scanpos = xsp;
39041     if (jj_scan_token(118)) {
39042     jj_scanpos = xsp;
39043     if (jj_scan_token(120)) {
39044     jj_scanpos = xsp;
39045     if (jj_scan_token(121)) {
39046     jj_scanpos = xsp;
39047     if (jj_scan_token(122)) {
39048     jj_scanpos = xsp;
39049     if (jj_scan_token(124)) {
39050     jj_scanpos = xsp;
39051     if (jj_scan_token(127)) {
39052     jj_scanpos = xsp;
39053     if (jj_scan_token(128)) {
39054     jj_scanpos = xsp;
39055     if (jj_scan_token(131)) {
39056     jj_scanpos = xsp;
39057     if (jj_scan_token(135)) {
39058     jj_scanpos = xsp;
39059     if (jj_scan_token(137)) {
39060     jj_scanpos = xsp;
39061     if (jj_scan_token(139)) {
39062     jj_scanpos = xsp;
39063     if (jj_scan_token(144)) {
39064     jj_scanpos = xsp;
39065     if (jj_scan_token(146)) {
39066     jj_scanpos = xsp;
39067     if (jj_scan_token(147)) {
39068     jj_scanpos = xsp;
39069     if (jj_scan_token(148)) {
39070     jj_scanpos = xsp;
39071     if (jj_scan_token(150)) {
39072     jj_scanpos = xsp;
39073     if (jj_scan_token(152)) {
39074     jj_scanpos = xsp;
39075     if (jj_scan_token(156)) {
39076     jj_scanpos = xsp;
39077     if (jj_scan_token(158)) {
39078     jj_scanpos = xsp;
39079     if (jj_scan_token(159)) {
39080     jj_scanpos = xsp;
39081     if (jj_scan_token(160)) {
39082     jj_scanpos = xsp;
39083     if (jj_scan_token(161)) {
39084     jj_scanpos = xsp;
39085     if (jj_scan_token(167)) {
39086     jj_scanpos = xsp;
39087     if (jj_scan_token(171)) {
39088     jj_scanpos = xsp;
39089     if (jj_scan_token(172)) {
39090     jj_scanpos = xsp;
39091     if (jj_scan_token(175)) {
39092     jj_scanpos = xsp;
39093     if (jj_scan_token(178)) {
39094     jj_scanpos = xsp;
39095     if (jj_scan_token(181)) {
39096     jj_scanpos = xsp;
39097     if (jj_scan_token(183)) {
39098     jj_scanpos = xsp;
39099     if (jj_scan_token(184)) {
39100     jj_scanpos = xsp;
39101     if (jj_scan_token(185)) {
39102     jj_scanpos = xsp;
39103     if (jj_scan_token(187)) {
39104     jj_scanpos = xsp;
39105     if (jj_scan_token(192)) {
39106     jj_scanpos = xsp;
39107     if (jj_scan_token(194)) {
39108     jj_scanpos = xsp;
39109     if (jj_scan_token(195)) {
39110     jj_scanpos = xsp;
39111     if (jj_scan_token(197)) {
39112     jj_scanpos = xsp;
39113     if (jj_scan_token(188)) {
39114     jj_scanpos = xsp;
39115     if (jj_scan_token(189)) {
39116     jj_scanpos = xsp;
39117     if (jj_scan_token(190)) {
39118     jj_scanpos = xsp;
39119     if (jj_scan_token(191)) {
39120     jj_scanpos = xsp;
39121     if (jj_scan_token(201)) {
39122     jj_scanpos = xsp;
39123     if (jj_scan_token(202)) {
39124     jj_scanpos = xsp;
39125     if (jj_scan_token(203)) {
39126     jj_scanpos = xsp;
39127     if (jj_scan_token(204)) {
39128     jj_scanpos = xsp;
39129     if (jj_scan_token(207)) {
39130     jj_scanpos = xsp;
39131     if (jj_scan_token(212)) {
39132     jj_scanpos = xsp;
39133     if (jj_scan_token(215)) {
39134     jj_scanpos = xsp;
39135     if (jj_scan_token(216)) {
39136     jj_scanpos = xsp;
39137     if (jj_scan_token(217)) {
39138     jj_scanpos = xsp;
39139     if (jj_scan_token(220)) {
39140     jj_scanpos = xsp;
39141     if (jj_scan_token(222)) {
39142     jj_scanpos = xsp;
39143     if (jj_scan_token(221)) {
39144     jj_scanpos = xsp;
39145     if (jj_scan_token(224)) {
39146     jj_scanpos = xsp;
39147     if (jj_scan_token(225)) {
39148     jj_scanpos = xsp;
39149     if (jj_scan_token(227)) {
39150     jj_scanpos = xsp;
39151     if (jj_scan_token(246)) {
39152     jj_scanpos = xsp;
39153     if (jj_scan_token(250)) {
39154     jj_scanpos = xsp;
39155     if (jj_scan_token(252)) {
39156     jj_scanpos = xsp;
39157     if (jj_scan_token(255)) {
39158     jj_scanpos = xsp;
39159     if (jj_scan_token(256)) {
39160     jj_scanpos = xsp;
39161     if (jj_scan_token(258)) {
39162     jj_scanpos = xsp;
39163     if (jj_scan_token(259)) {
39164     jj_scanpos = xsp;
39165     if (jj_scan_token(260)) {
39166     jj_scanpos = xsp;
39167     if (jj_scan_token(261)) {
39168     jj_scanpos = xsp;
39169     if (jj_scan_token(263)) {
39170     jj_scanpos = xsp;
39171     if (jj_scan_token(267)) {
39172     jj_scanpos = xsp;
39173     if (jj_scan_token(268)) {
39174     jj_scanpos = xsp;
39175     if (jj_scan_token(269)) {
39176     jj_scanpos = xsp;
39177     if (jj_scan_token(271)) {
39178     jj_scanpos = xsp;
39179     if (jj_scan_token(273)) {
39180     jj_scanpos = xsp;
39181     if (jj_scan_token(280)) {
39182     jj_scanpos = xsp;
39183     if (jj_scan_token(282)) {
39184     jj_scanpos = xsp;
39185     if (jj_scan_token(284)) {
39186     jj_scanpos = xsp;
39187     if (jj_scan_token(285)) {
39188     jj_scanpos = xsp;
39189     if (jj_scan_token(297)) {
39190     jj_scanpos = xsp;
39191     if (jj_scan_token(298)) {
39192     jj_scanpos = xsp;
39193     if (jj_scan_token(299)) {
39194     jj_scanpos = xsp;
39195     if (jj_scan_token(303)) {
39196     jj_scanpos = xsp;
39197     if (jj_scan_token(305)) {
39198     jj_scanpos = xsp;
39199     if (jj_scan_token(308)) {
39200     jj_scanpos = xsp;
39201     if (jj_scan_token(318)) {
39202     jj_scanpos = xsp;
39203     if (jj_scan_token(292)) {
39204     jj_scanpos = xsp;
39205     if (jj_scan_token(432)) {
39206     jj_scanpos = xsp;
39207     if (jj_scan_token(429)) {
39208     jj_scanpos = xsp;
39209     if (jj_scan_token(430)) {
39210     jj_scanpos = xsp;
39211     if (jj_scan_token(431)) return true;
39212     }
39213     }
39214     }
39215     }
39216     }
39217     }
39218     }
39219     }
39220     }
39221     }
39222     }
39223     }
39224     }
39225     }
39226     }
39227     }
39228     }
39229     }
39230     }
39231     }
39232     }
39233     }
39234     }
39235     }
39236     }
39237     }
39238     }
39239     }
39240     }
39241     }
39242     }
39243     }
39244     }
39245     }
39246     }
39247     }
39248     }
39249     }
39250     }
39251     }
39252     }
39253     }
39254     }
39255     }
39256     }
39257     }
39258     }
39259     }
39260     }
39261     }
39262     }
39263     }
39264     }
39265     }
39266     }
39267     }
39268     }
39269     }
39270     }
39271     }
39272     }
39273     }
39274     }
39275     }
39276     }
39277     }
39278     }
39279     }
39280     }
39281     }
39282     }
39283     }
39284     }
39285     }
39286     }
39287     }
39288     }
39289     }
39290     }
39291     }
39292     }
39293     }
39294     }
39295     }
39296     }
39297     }
39298     }
39299     }
39300     }
39301     }
39302     }
39303     }
39304     }
39305     }
39306     }
39307     }
39308     }
39309     }
39310     }
39311     }
39312     }
39313     }
39314     }
39315     }
39316     }
39317     }
39318     }
39319     }
39320     }
39321     }
39322     }
39323     }
39324     }
39325     }
39326     }
39327     }
39328     }
39329     }
39330     }
39331     }
39332     }
39333     }
39334     }
39335     }
39336     }
39337     }
39338     }
39339     }
39340     }
39341     }
39342     }
39343     return false;
39344   }
39345 
39346   private boolean jj_3R_583() {
39347     if (jj_scan_token(EXCEPT)) return true;
39348     return false;
39349   }
39350 
39351   private boolean jj_3R_158() {
39352     Token xsp;
39353     xsp = jj_scanpos;
39354     if (jj_scan_token(152)) {
39355     jj_scanpos = xsp;
39356     if (jj_scan_token(51)) return true;
39357     }
39358     if (jj_3R_192()) return true;
39359     if (jj_scan_token(END)) return true;
39360     xsp = jj_scanpos;
39361     if (jj_3R_250()) jj_scanpos = xsp;
39362     if (jj_scan_token(4)) return true;
39363     return false;
39364   }
39365 
39366   private boolean jj_3R_157() {
39367     if (jj_3R_249()) return true;
39368     return false;
39369   }
39370 
39371   private boolean jj_3R_245() {
39372     if (jj_scan_token(OR)) return true;
39373     if (jj_scan_token(REPLACE)) return true;
39374     return false;
39375   }
39376 
39377   private boolean jj_3R_612() {
39378     if (jj_scan_token(OF)) return true;
39379     return false;
39380   }
39381 
39382   private boolean jj_3R_248() {
39383     if (jj_3R_239()) return true;
39384     return false;
39385   }
39386 
39387   private boolean jj_3R_541() {
39388     if (jj_scan_token(MULTISET)) return true;
39389     Token xsp;
39390     xsp = jj_scanpos;
39391     if (jj_3R_583()) {
39392     jj_scanpos = xsp;
39393     if (jj_3R_584()) {
39394     jj_scanpos = xsp;
39395     if (jj_3R_585()) return true;
39396     }
39397     }
39398     xsp = jj_scanpos;
39399     if (jj_3R_586()) jj_scanpos = xsp;
39400     return false;
39401   }
39402 
39403   private boolean jj_3R_611() {
39404     if (jj_scan_token(SUBMULTISET)) return true;
39405     return false;
39406   }
39407 
39408   private boolean jj_3R_156() {
39409     Token xsp;
39410     xsp = jj_scanpos;
39411     if (jj_3R_247()) {
39412     jj_scanpos = xsp;
39413     if (jj_3R_248()) return true;
39414     }
39415     return false;
39416   }
39417 
39418   private boolean jj_3R_247() {
39419     if (jj_scan_token(AUTHID)) return true;
39420     Token xsp;
39421     xsp = jj_scanpos;
39422     if (jj_scan_token(37)) {
39423     jj_scanpos = xsp;
39424     if (jj_scan_token(36)) return true;
39425     }
39426     return false;
39427   }
39428 
39429   private boolean jj_3R_610() {
39430     if (jj_scan_token(MEMBER)) return true;
39431     return false;
39432   }
39433 
39434   private boolean jj_3R_154() {
39435     if (jj_scan_token(CREATE)) return true;
39436     Token xsp;
39437     xsp = jj_scanpos;
39438     if (jj_3R_245()) jj_scanpos = xsp;
39439     xsp = jj_scanpos;
39440     if (jj_3R_246()) jj_scanpos = xsp;
39441     return false;
39442   }
39443 
39444   private boolean jj_3R_582() {
39445     Token xsp;
39446     xsp = jj_scanpos;
39447     if (jj_3R_610()) {
39448     jj_scanpos = xsp;
39449     if (jj_3R_611()) return true;
39450     }
39451     xsp = jj_scanpos;
39452     if (jj_3R_612()) jj_scanpos = xsp;
39453     return false;
39454   }
39455 
39456   private boolean jj_3R_581() {
39457     if (jj_scan_token(FROM)) return true;
39458     return false;
39459   }
39460 
39461   private boolean jj_3R_580() {
39462     if (jj_scan_token(LIKE)) return true;
39463     return false;
39464   }
39465 
39466   private boolean jj_3R_103() {
39467     Token xsp;
39468     xsp = jj_scanpos;
39469     if (jj_3R_154()) jj_scanpos = xsp;
39470     if (jj_scan_token(PACKAGE)) return true;
39471     if (jj_3R_155()) return true;
39472     while (true) {
39473       xsp = jj_scanpos;
39474       if (jj_3R_156()) { jj_scanpos = xsp; break; }
39475     }
39476     xsp = jj_scanpos;
39477     if (jj_3R_157()) {
39478     jj_scanpos = xsp;
39479     if (jj_3R_158()) return true;
39480     }
39481     return false;
39482   }
39483 
39484   private boolean jj_3R_579() {
39485     if (jj_scan_token(BETWEEN)) return true;
39486     return false;
39487   }
39488 
39489   private boolean jj_3R_578() {
39490     if (jj_scan_token(IN)) return true;
39491     return false;
39492   }
39493 
39494   private boolean jj_3R_609() {
39495     if (jj_scan_token(15)) return true;
39496     return false;
39497   }
39498 
39499   private boolean jj_3R_577() {
39500     if (jj_scan_token(NOT)) return true;
39501     return false;
39502   }
39503 
39504   private boolean jj_3R_576() {
39505     if (jj_scan_token(10)) return true;
39506     return false;
39507   }
39508 
39509   private boolean jj_3R_575() {
39510     if (jj_scan_token(15)) return true;
39511     return false;
39512   }
39513 
39514   private boolean jj_3R_117() {
39515     if (jj_scan_token(DECLARE)) return true;
39516     if (jj_3R_192()) return true;
39517     return false;
39518   }
39519 
39520   private boolean jj_3R_540() {
39521     Token xsp;
39522     xsp = jj_scanpos;
39523     if (jj_3R_577()) jj_scanpos = xsp;
39524     xsp = jj_scanpos;
39525     if (jj_3R_578()) {
39526     jj_scanpos = xsp;
39527     if (jj_3R_579()) {
39528     jj_scanpos = xsp;
39529     if (jj_3R_580()) {
39530     jj_scanpos = xsp;
39531     if (jj_3R_581()) {
39532     jj_scanpos = xsp;
39533     if (jj_3R_582()) return true;
39534     }
39535     }
39536     }
39537     }
39538     return false;
39539   }
39540 
39541   private boolean jj_3R_574() {
39542     if (jj_scan_token(14)) return true;
39543     Token xsp;
39544     xsp = jj_scanpos;
39545     if (jj_3R_609()) jj_scanpos = xsp;
39546     return false;
39547   }
39548 
39549   private boolean jj_3R_322() {
39550     if (jj_3R_351()) return true;
39551     return false;
39552   }
39553 
39554   private boolean jj_3R_321() {
39555     if (jj_3R_174()) return true;
39556     return false;
39557   }
39558 
39559   private boolean jj_3R_539() {
39560     Token xsp;
39561     xsp = jj_scanpos;
39562     if (jj_3R_574()) {
39563     jj_scanpos = xsp;
39564     if (jj_3R_575()) return true;
39565     }
39566     xsp = jj_scanpos;
39567     if (jj_3R_576()) jj_scanpos = xsp;
39568     return false;
39569   }
39570 
39571   private boolean jj_3R_116() {
39572     if (jj_3R_191()) return true;
39573     return false;
39574   }
39575 
39576   private boolean jj_3_14() {
39577     Token xsp;
39578     while (true) {
39579       xsp = jj_scanpos;
39580       if (jj_3R_116()) { jj_scanpos = xsp; break; }
39581     }
39582     xsp = jj_scanpos;
39583     if (jj_3R_117()) jj_scanpos = xsp;
39584     if (jj_scan_token(BEGIN)) return true;
39585     return false;
39586   }
39587 
39588   private boolean jj_3R_509() {
39589     Token xsp;
39590     xsp = jj_scanpos;
39591     if (jj_3R_539()) {
39592     jj_scanpos = xsp;
39593     if (jj_3R_540()) {
39594     jj_scanpos = xsp;
39595     if (jj_3R_541()) return true;
39596     }
39597     }
39598     if (jj_3R_508()) return true;
39599     xsp = jj_scanpos;
39600     if (jj_3R_542()) jj_scanpos = xsp;
39601     return false;
39602   }
39603 
39604   private boolean jj_3R_320() {
39605     if (jj_scan_token(DECLARE)) return true;
39606     if (jj_3R_192()) return true;
39607     return false;
39608   }
39609 
39610   private boolean jj_3R_272() {
39611     Token xsp;
39612     xsp = jj_scanpos;
39613     if (jj_3R_320()) jj_scanpos = xsp;
39614     if (jj_scan_token(BEGIN)) return true;
39615     while (true) {
39616       xsp = jj_scanpos;
39617       if (jj_3R_321()) { jj_scanpos = xsp; break; }
39618     }
39619     xsp = jj_scanpos;
39620     if (jj_3R_322()) jj_scanpos = xsp;
39621     if (jj_scan_token(END)) return true;
39622     xsp = jj_scanpos;
39623     if (jj_scan_token(420)) jj_scanpos = xsp;
39624     return false;
39625   }
39626 
39627   private boolean jj_3R_482() {
39628     if (jj_3R_508()) return true;
39629     Token xsp;
39630     while (true) {
39631       xsp = jj_scanpos;
39632       if (jj_3R_509()) { jj_scanpos = xsp; break; }
39633     }
39634     return false;
39635   }
39636 
39637   private boolean jj_3R_186() {
39638     Token xsp;
39639     while (true) {
39640       xsp = jj_scanpos;
39641       if (jj_3R_271()) { jj_scanpos = xsp; break; }
39642     }
39643     if (jj_3R_272()) return true;
39644     if (jj_scan_token(4)) return true;
39645     return false;
39646   }
39647 
39648   private boolean jj_3R_512() {
39649     if (jj_scan_token(IS)) return true;
39650     return false;
39651   }
39652 
39653   private boolean jj_3R_511() {
39654     if (jj_scan_token(13)) return true;
39655     if (jj_scan_token(10)) return true;
39656     return false;
39657   }
39658 
39659   private boolean jj_3R_510() {
39660     if (jj_scan_token(10)) return true;
39661     return false;
39662   }
39663 
39664   private boolean jj_3R_483() {
39665     Token xsp;
39666     xsp = jj_scanpos;
39667     if (jj_3R_510()) {
39668     jj_scanpos = xsp;
39669     if (jj_3R_511()) {
39670     jj_scanpos = xsp;
39671     if (jj_3R_512()) return true;
39672     }
39673     }
39674     if (jj_3R_482()) return true;
39675     return false;
39676   }
39677 
39678   private boolean jj_3R_113() {
39679     Token xsp;
39680     xsp = jj_scanpos;
39681     if (jj_3R_186()) {
39682     jj_scanpos = xsp;
39683     if (jj_3_15()) return true;
39684     }
39685     return false;
39686   }
39687 
39688   private boolean jj_3R_437() {
39689     if (jj_3R_482()) return true;
39690     Token xsp;
39691     while (true) {
39692       xsp = jj_scanpos;
39693       if (jj_3R_483()) { jj_scanpos = xsp; break; }
39694     }
39695     return false;
39696   }
39697 
39698   private boolean jj_3R_438() {
39699     if (jj_scan_token(AND)) return true;
39700     if (jj_3R_437()) return true;
39701     return false;
39702   }
39703 
39704   private boolean jj_3R_395() {
39705     if (jj_3R_437()) return true;
39706     Token xsp;
39707     while (true) {
39708       xsp = jj_scanpos;
39709       if (jj_3R_438()) { jj_scanpos = xsp; break; }
39710     }
39711     return false;
39712   }
39713 
39714   private boolean jj_3R_396() {
39715     if (jj_scan_token(OR)) return true;
39716     if (jj_3R_395()) return true;
39717     return false;
39718   }
39719 
39720   private boolean jj_3R_189() {
39721     if (jj_scan_token(3)) return true;
39722     if (jj_scan_token(ATTACH)) return true;
39723     return false;
39724   }
39725 
39726   private boolean jj_3R_344() {
39727     if (jj_3R_395()) return true;
39728     Token xsp;
39729     while (true) {
39730       xsp = jj_scanpos;
39731       if (jj_3R_396()) { jj_scanpos = xsp; break; }
39732     }
39733     return false;
39734   }
39735 
39736   private boolean jj_3R_237() {
39737     if (jj_scan_token(3)) return true;
39738     if (jj_3R_234()) return true;
39739     return false;
39740   }
39741 
39742   private boolean jj_3R_235() {
39743     if (jj_scan_token(AT)) return true;
39744     if (jj_scan_token(TIME)) return true;
39745     if (jj_scan_token(ZONE)) return true;
39746     if (jj_3R_133()) return true;
39747     return false;
39748   }
39749 
39750   private boolean jj_3R_140() {
39751     Token xsp;
39752     xsp = jj_scanpos;
39753     if (jj_scan_token(390)) {
39754     jj_scanpos = xsp;
39755     if (jj_scan_token(391)) return true;
39756     }
39757     if (jj_scan_token(5)) return true;
39758     if (jj_3R_234()) return true;
39759     xsp = jj_scanpos;
39760     if (jj_3R_235()) jj_scanpos = xsp;
39761     if (jj_scan_token(AS)) return true;
39762     if (jj_3R_236()) return true;
39763     if (jj_scan_token(7)) return true;
39764     while (true) {
39765       xsp = jj_scanpos;
39766       if (jj_3R_237()) { jj_scanpos = xsp; break; }
39767     }
39768     return false;
39769   }
39770 
39771   private boolean jj_3R_229() {
39772     if (jj_3R_230()) return true;
39773     return false;
39774   }
39775 
39776   private boolean jj_3R_228() {
39777     Token xsp;
39778     xsp = jj_scanpos;
39779     if (jj_scan_token(399)) {
39780     jj_scanpos = xsp;
39781     if (jj_scan_token(400)) {
39782     jj_scanpos = xsp;
39783     if (jj_scan_token(395)) return true;
39784     }
39785     }
39786     return false;
39787   }
39788 
39789   private boolean jj_3R_115() {
39790     Token xsp;
39791     xsp = jj_scanpos;
39792     if (jj_scan_token(2)) {
39793     jj_scanpos = xsp;
39794     if (jj_scan_token(377)) {
39795     jj_scanpos = xsp;
39796     if (jj_scan_token(74)) {
39797     jj_scanpos = xsp;
39798     if (jj_scan_token(78)) {
39799     jj_scanpos = xsp;
39800     if (jj_scan_token(379)) {
39801     jj_scanpos = xsp;
39802     if (jj_scan_token(380)) {
39803     jj_scanpos = xsp;
39804     if (jj_scan_token(381)) {
39805     jj_scanpos = xsp;
39806     if (jj_scan_token(111)) {
39807     jj_scanpos = xsp;
39808     if (jj_scan_token(113)) {
39809     jj_scanpos = xsp;
39810     if (jj_scan_token(382)) {
39811     jj_scanpos = xsp;
39812     if (jj_scan_token(383)) {
39813     jj_scanpos = xsp;
39814     if (jj_scan_token(221)) {
39815     jj_scanpos = xsp;
39816     if (jj_scan_token(384)) {
39817     jj_scanpos = xsp;
39818     if (jj_scan_token(385)) {
39819     jj_scanpos = xsp;
39820     if (jj_scan_token(253)) {
39821     jj_scanpos = xsp;
39822     if (jj_scan_token(294)) {
39823     jj_scanpos = xsp;
39824     if (jj_scan_token(295)) {
39825     jj_scanpos = xsp;
39826     if (jj_scan_token(261)) {
39827     jj_scanpos = xsp;
39828     if (jj_scan_token(386)) {
39829     jj_scanpos = xsp;
39830     if (jj_scan_token(387)) {
39831     jj_scanpos = xsp;
39832     if (jj_scan_token(388)) {
39833     jj_scanpos = xsp;
39834     if (jj_scan_token(75)) {
39835     jj_scanpos = xsp;
39836     if (jj_scan_token(129)) {
39837     jj_scanpos = xsp;
39838     if (jj_scan_token(240)) {
39839     jj_scanpos = xsp;
39840     if (jj_scan_token(99)) {
39841     jj_scanpos = xsp;
39842     if (jj_scan_token(420)) {
39843     jj_scanpos = xsp;
39844     if (jj_3R_189()) return true;
39845     }
39846     }
39847     }
39848     }
39849     }
39850     }
39851     }
39852     }
39853     }
39854     }
39855     }
39856     }
39857     }
39858     }
39859     }
39860     }
39861     }
39862     }
39863     }
39864     }
39865     }
39866     }
39867     }
39868     }
39869     }
39870     }
39871     if (jj_3R_190()) return true;
39872     return false;
39873   }
39874 
39875   private boolean jj_3R_138() {
39876     if (jj_scan_token(TRIM)) return true;
39877     if (jj_scan_token(5)) return true;
39878     Token xsp;
39879     xsp = jj_scanpos;
39880     if (jj_3R_228()) jj_scanpos = xsp;
39881     xsp = jj_scanpos;
39882     if (jj_3R_229()) jj_scanpos = xsp;
39883     if (jj_scan_token(FROM)) return true;
39884     if (jj_3R_230()) return true;
39885     if (jj_scan_token(7)) return true;
39886     return false;
39887   }
39888 
39889   private boolean jj_3R_114() {
39890     if (jj_3R_187()) return true;
39891     if (jj_3R_188()) return true;
39892     return false;
39893   }
39894 
39895   private boolean jj_3_13() {
39896     if (jj_3R_115()) return true;
39897     return false;
39898   }
39899 
39900   private boolean jj_3_12() {
39901     if (jj_3R_114()) return true;
39902     return false;
39903   }
39904 
39905   private boolean jj_3_11() {
39906     if (jj_3R_113()) return true;
39907     return false;
39908   }
39909 
39910   private boolean jj_3_10() {
39911     if (jj_3R_112()) return true;
39912     return false;
39913   }
39914 
39915   private boolean jj_3_9() {
39916     if (jj_3R_111()) return true;
39917     return false;
39918   }
39919 
39920   private boolean jj_3_8() {
39921     if (jj_3R_110()) return true;
39922     return false;
39923   }
39924 
39925   private boolean jj_3_7() {
39926     if (jj_3R_109()) return true;
39927     return false;
39928   }
39929 
39930   private boolean jj_3_6() {
39931     if (jj_3R_108()) return true;
39932     return false;
39933   }
39934 
39935   private boolean jj_3_5() {
39936     if (jj_3R_107()) return true;
39937     return false;
39938   }
39939 
39940   private boolean jj_3_4() {
39941     if (jj_3R_106()) return true;
39942     return false;
39943   }
39944 
39945   private boolean jj_3_3() {
39946     if (jj_3R_105()) return true;
39947     return false;
39948   }
39949 
39950   private boolean jj_3_2() {
39951     if (jj_3R_104()) return true;
39952     return false;
39953   }
39954 
39955   private boolean jj_3_1() {
39956     if (jj_3R_103()) return true;
39957     return false;
39958   }
39959 
39960   private boolean jj_3R_233() {
39961     if (jj_scan_token(ELSE)) return true;
39962     if (jj_3R_234()) return true;
39963     return false;
39964   }
39965 
39966   private boolean jj_3R_232() {
39967     if (jj_scan_token(WHEN)) return true;
39968     if (jj_3R_234()) return true;
39969     if (jj_scan_token(THEN)) return true;
39970     if (jj_3R_234()) return true;
39971     return false;
39972   }
39973 
39974   private boolean jj_3R_231() {
39975     if (jj_3R_234()) return true;
39976     return false;
39977   }
39978 
39979   private boolean jj_3R_139() {
39980     if (jj_scan_token(CASE)) return true;
39981     Token xsp;
39982     xsp = jj_scanpos;
39983     if (jj_3R_231()) jj_scanpos = xsp;
39984     if (jj_3R_232()) return true;
39985     while (true) {
39986       xsp = jj_scanpos;
39987       if (jj_3R_232()) { jj_scanpos = xsp; break; }
39988     }
39989     xsp = jj_scanpos;
39990     if (jj_3R_233()) jj_scanpos = xsp;
39991     if (jj_scan_token(END)) return true;
39992     return false;
39993   }
39994 
39995   private boolean jj_3R_343() {
39996     if (jj_3R_133()) return true;
39997     if (jj_scan_token(9)) return true;
39998     if (jj_scan_token(10)) return true;
39999     if (jj_3R_234()) return true;
40000     return false;
40001   }
40002 
40003   private boolean jj_3R_398() {
40004     if (jj_scan_token(CC_ELSE)) return true;
40005     if (jj_3R_234()) return true;
40006     return false;
40007   }
40008 
40009   private boolean jj_3R_397() {
40010     if (jj_scan_token(CC_ELSIF)) return true;
40011     if (jj_3R_344()) return true;
40012     if (jj_scan_token(CC_THEN)) return true;
40013     if (jj_3R_234()) return true;
40014     return false;
40015   }
40016 
40017   private boolean jj_3R_109() {
40018     if (jj_scan_token(ALTER)) return true;
40019     if (jj_scan_token(TRIGGER)) return true;
40020     if (jj_3R_180()) return true;
40021     if (jj_scan_token(4)) return true;
40022     return false;
40023   }
40024 
40025   private boolean jj_3R_319() {
40026     if (jj_3R_378()) return true;
40027     return false;
40028   }
40029 
40030   private boolean jj_3R_345() {
40031     if (jj_scan_token(CC_IF)) return true;
40032     if (jj_3R_344()) return true;
40033     if (jj_scan_token(CC_THEN)) return true;
40034     if (jj_3R_234()) return true;
40035     Token xsp;
40036     while (true) {
40037       xsp = jj_scanpos;
40038       if (jj_3R_397()) { jj_scanpos = xsp; break; }
40039     }
40040     while (true) {
40041       xsp = jj_scanpos;
40042       if (jj_3R_398()) { jj_scanpos = xsp; break; }
40043     }
40044     if (jj_scan_token(CC_END)) return true;
40045     return false;
40046   }
40047 
40048   private boolean jj_3_45() {
40049     if (jj_3R_133()) return true;
40050     if (jj_scan_token(9)) return true;
40051     if (jj_scan_token(10)) return true;
40052     return false;
40053   }
40054 
40055   private boolean jj_3R_318() {
40056     if (jj_3R_187()) return true;
40057     return false;
40058   }
40059 
40060   private boolean jj_3R_268() {
40061     Token xsp;
40062     xsp = jj_scanpos;
40063     if (jj_3R_318()) {
40064     jj_scanpos = xsp;
40065     if (jj_3R_319()) return true;
40066     }
40067     return false;
40068   }
40069 
40070   private boolean jj_3R_303() {
40071     if (jj_3R_345()) return true;
40072     return false;
40073   }
40074 
40075   private boolean jj_3R_302() {
40076     if (jj_3R_344()) return true;
40077     return false;
40078   }
40079 
40080   private boolean jj_3R_301() {
40081     if (jj_3R_343()) return true;
40082     return false;
40083   }
40084 
40085   private boolean jj_3R_234() {
40086     Token xsp;
40087     xsp = jj_scanpos;
40088     if (jj_3R_301()) {
40089     jj_scanpos = xsp;
40090     if (jj_3R_302()) {
40091     jj_scanpos = xsp;
40092     if (jj_3R_303()) return true;
40093     }
40094     }
40095     return false;
40096   }
40097 
40098   private boolean jj_3R_378() {
40099     Token xsp;
40100     xsp = jj_scanpos;
40101     if (jj_scan_token(361)) {
40102     jj_scanpos = xsp;
40103     if (jj_scan_token(360)) {
40104     jj_scanpos = xsp;
40105     if (jj_scan_token(355)) {
40106     jj_scanpos = xsp;
40107     if (jj_scan_token(354)) {
40108     jj_scanpos = xsp;
40109     if (jj_scan_token(359)) {
40110     jj_scanpos = xsp;
40111     if (jj_scan_token(364)) return true;
40112     }
40113     }
40114     }
40115     }
40116     }
40117     return false;
40118   }
40119 
40120   private boolean jj_3R_274() {
40121     if (jj_scan_token(DISASSOCIATE)) return true;
40122     if (jj_scan_token(STATISTICS)) return true;
40123     return false;
40124   }
40125 
40126   private boolean jj_3_85() {
40127     if (jj_3R_124()) return true;
40128     if (jj_scan_token(3)) return true;
40129     return false;
40130   }
40131 
40132   private boolean jj_3R_273() {
40133     if (jj_scan_token(ASSOCIATE)) return true;
40134     if (jj_scan_token(STATISTICS)) return true;
40135     return false;
40136   }
40137 
40138   private boolean jj_3R_187() {
40139     Token xsp;
40140     xsp = jj_scanpos;
40141     if (jj_scan_token(47)) {
40142     jj_scanpos = xsp;
40143     if (jj_scan_token(344)) {
40144     jj_scanpos = xsp;
40145     if (jj_3R_273()) {
40146     jj_scanpos = xsp;
40147     if (jj_scan_token(346)) {
40148     jj_scanpos = xsp;
40149     if (jj_scan_token(75)) {
40150     jj_scanpos = xsp;
40151     if (jj_scan_token(83)) {
40152     jj_scanpos = xsp;
40153     if (jj_3R_274()) {
40154     jj_scanpos = xsp;
40155     if (jj_scan_token(99)) {
40156     jj_scanpos = xsp;
40157     if (jj_scan_token(129)) {
40158     jj_scanpos = xsp;
40159     if (jj_scan_token(357)) {
40160     jj_scanpos = xsp;
40161     if (jj_scan_token(233)) {
40162     jj_scanpos = xsp;
40163     if (jj_scan_token(240)) {
40164     jj_scanpos = xsp;
40165     if (jj_scan_token(365)) {
40166     jj_scanpos = xsp;
40167     if (jj_scan_token(350)) return true;
40168     }
40169     }
40170     }
40171     }
40172     }
40173     }
40174     }
40175     }
40176     }
40177     }
40178     }
40179     }
40180     }
40181     return false;
40182   }
40183 
40184   private boolean jj_3R_424() {
40185     if (jj_3R_199()) return true;
40186     return false;
40187   }
40188 
40189   private boolean jj_3R_122() {
40190     if (jj_3R_199()) return true;
40191     return false;
40192   }
40193 
40194   private boolean jj_3R_502() {
40195     if (jj_scan_token(IS)) return true;
40196     Token xsp;
40197     while (true) {
40198       xsp = jj_scanpos;
40199       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
40200     }
40201     if (jj_3R_405()) return true;
40202     return false;
40203   }
40204 
40205   private boolean jj_3R_501() {
40206     if (jj_scan_token(RETURN)) return true;
40207     if (jj_3R_236()) return true;
40208     return false;
40209   }
40210 
40211   private boolean jj_3R_500() {
40212     if (jj_3R_386()) return true;
40213     return false;
40214   }
40215 
40216   private boolean jj_3_80() {
40217     if (jj_3R_124()) return true;
40218     if (jj_scan_token(3)) return true;
40219     return false;
40220   }
40221 
40222   private boolean jj_3R_199() {
40223     if (jj_scan_token(CURSOR)) return true;
40224     if (jj_3R_124()) return true;
40225     Token xsp;
40226     xsp = jj_scanpos;
40227     if (jj_3R_500()) jj_scanpos = xsp;
40228     xsp = jj_scanpos;
40229     if (jj_3R_501()) jj_scanpos = xsp;
40230     xsp = jj_scanpos;
40231     if (jj_3R_502()) jj_scanpos = xsp;
40232     if (jj_scan_token(4)) return true;
40233     return false;
40234   }
40235 
40236   private boolean jj_3_84() {
40237     if (jj_3R_122()) return true;
40238     return false;
40239   }
40240 
40241   private boolean jj_3R_270() {
40242     if (jj_3R_268()) return true;
40243     return false;
40244   }
40245 
40246   private boolean jj_3_83() {
40247     if (jj_3R_121()) return true;
40248     return false;
40249   }
40250 
40251   private boolean jj_3_82() {
40252     if (jj_3R_153()) return true;
40253     return false;
40254   }
40255 
40256   private boolean jj_3_81() {
40257     if (jj_3R_119()) return true;
40258     return false;
40259   }
40260 
40261   private boolean jj_3R_177() {
40262     if (jj_3R_268()) return true;
40263     return false;
40264   }
40265 
40266   private boolean jj_3R_563() {
40267     if (jj_3R_183()) return true;
40268     return false;
40269   }
40270 
40271   private boolean jj_3R_633() {
40272     if (jj_3R_183()) return true;
40273     return false;
40274   }
40275 
40276   private boolean jj_3R_152() {
40277     if (jj_scan_token(6)) return true;
40278     if (jj_3R_124()) return true;
40279     return false;
40280   }
40281 
40282   private boolean jj_3R_562() {
40283     if (jj_3R_183()) return true;
40284     return false;
40285   }
40286 
40287   private boolean jj_3R_151() {
40288     if (jj_scan_token(6)) return true;
40289     if (jj_3R_124()) return true;
40290     return false;
40291   }
40292 
40293   private boolean jj_3R_425() {
40294     if (jj_scan_token(IDENTIFIER)) return true;
40295     return false;
40296   }
40297 
40298   private boolean jj_3_76() {
40299     if (jj_3R_124()) return true;
40300     if (jj_scan_token(3)) return true;
40301     return false;
40302   }
40303 
40304   private boolean jj_3_79() {
40305     if (jj_3R_124()) return true;
40306     if (jj_scan_token(3)) return true;
40307     return false;
40308   }
40309 
40310   private boolean jj_3_75() {
40311     if (jj_scan_token(OF)) return true;
40312     if (jj_3R_124()) return true;
40313     Token xsp;
40314     while (true) {
40315       xsp = jj_scanpos;
40316       if (jj_3R_152()) { jj_scanpos = xsp; break; }
40317     }
40318     return false;
40319   }
40320 
40321   private boolean jj_3_74() {
40322     if (jj_scan_token(OF)) return true;
40323     if (jj_3R_124()) return true;
40324     Token xsp;
40325     while (true) {
40326       xsp = jj_scanpos;
40327       if (jj_3R_151()) { jj_scanpos = xsp; break; }
40328     }
40329     return false;
40330   }
40331 
40332   private boolean jj_3R_630() {
40333     if (jj_scan_token(3)) return true;
40334     Token xsp;
40335     xsp = jj_scanpos;
40336     if (jj_scan_token(420)) {
40337     jj_scanpos = xsp;
40338     if (jj_scan_token(428)) {
40339     jj_scanpos = xsp;
40340     if (jj_3R_633()) return true;
40341     }
40342     }
40343     return false;
40344   }
40345 
40346   private boolean jj_3R_599() {
40347     if (jj_scan_token(9)) return true;
40348     if (jj_scan_token(10)) return true;
40349     return false;
40350   }
40351 
40352   private boolean jj_3R_290() {
40353     if (jj_scan_token(PARAMETERS)) return true;
40354     if (jj_3R_564()) return true;
40355     return false;
40356   }
40357 
40358   private boolean jj_3R_566() {
40359     Token xsp;
40360     xsp = jj_scanpos;
40361     if (jj_3R_599()) {
40362     jj_scanpos = xsp;
40363     if (jj_scan_token(92)) return true;
40364     }
40365     if (jj_3R_234()) return true;
40366     return false;
40367   }
40368 
40369   private boolean jj_3R_526() {
40370     if (jj_scan_token(5)) return true;
40371     if (jj_3R_127()) return true;
40372     if (jj_scan_token(7)) return true;
40373     return false;
40374   }
40375 
40376   private boolean jj_3R_289() {
40377     if (jj_scan_token(WITH)) return true;
40378     if (jj_scan_token(CONTEXT)) return true;
40379     return false;
40380   }
40381 
40382   private boolean jj_3R_288() {
40383     if (jj_scan_token(NAME)) return true;
40384     Token xsp;
40385     xsp = jj_scanpos;
40386     if (jj_scan_token(420)) {
40387     jj_scanpos = xsp;
40388     if (jj_scan_token(428)) {
40389     jj_scanpos = xsp;
40390     if (jj_3R_563()) return true;
40391     }
40392     }
40393     return false;
40394   }
40395 
40396   private boolean jj_3R_267() {
40397     Token xsp;
40398     xsp = jj_scanpos;
40399     if (jj_scan_token(100)) {
40400     jj_scanpos = xsp;
40401     if (jj_scan_token(182)) return true;
40402     }
40403     return false;
40404   }
40405 
40406   private boolean jj_3R_528() {
40407     if (jj_scan_token(INDEX)) return true;
40408     if (jj_scan_token(BY)) return true;
40409     if (jj_3R_236()) return true;
40410     return false;
40411   }
40412 
40413   private boolean jj_3R_524() {
40414     if (jj_scan_token(6)) return true;
40415     if (jj_3R_522()) return true;
40416     return false;
40417   }
40418 
40419   private boolean jj_3R_201() {
40420     Token xsp;
40421     xsp = jj_scanpos;
40422     if (jj_3R_287()) {
40423     jj_scanpos = xsp;
40424     if (jj_3R_288()) {
40425     jj_scanpos = xsp;
40426     if (jj_3R_289()) {
40427     jj_scanpos = xsp;
40428     if (jj_3R_290()) return true;
40429     }
40430     }
40431     }
40432     return false;
40433   }
40434 
40435   private boolean jj_3R_287() {
40436     if (jj_scan_token(LIBRARY)) return true;
40437     Token xsp;
40438     xsp = jj_scanpos;
40439     if (jj_scan_token(420)) {
40440     jj_scanpos = xsp;
40441     if (jj_scan_token(428)) {
40442     jj_scanpos = xsp;
40443     if (jj_3R_562()) return true;
40444     }
40445     }
40446     xsp = jj_scanpos;
40447     if (jj_3R_630()) jj_scanpos = xsp;
40448     return false;
40449   }
40450 
40451   private boolean jj_3R_523() {
40452     if (jj_scan_token(6)) return true;
40453     if (jj_3R_522()) return true;
40454     return false;
40455   }
40456 
40457   /** Generated Token Manager. */
40458   public PLSQLParserTokenManager token_source;
40459   SimpleCharStream jj_input_stream;
40460   /** Current token. */
40461   public Token token;
40462   /** Next token. */
40463   public Token jj_nt;
40464   private Token jj_scanpos, jj_lastpos;
40465   private int jj_la;
40466   private int jj_gen;
40467   final private int[] jj_la1 = new int[460];
40468   static private int[] jj_la1_0;
40469   static private int[] jj_la1_1;
40470   static private int[] jj_la1_2;
40471   static private int[] jj_la1_3;
40472   static private int[] jj_la1_4;
40473   static private int[] jj_la1_5;
40474   static private int[] jj_la1_6;
40475   static private int[] jj_la1_7;
40476   static private int[] jj_la1_8;
40477   static private int[] jj_la1_9;
40478   static private int[] jj_la1_10;
40479   static private int[] jj_la1_11;
40480   static private int[] jj_la1_12;
40481   static private int[] jj_la1_13;
40482   static {
40483       jj_la1_init_0();
40484       jj_la1_init_1();
40485       jj_la1_init_2();
40486       jj_la1_init_3();
40487       jj_la1_init_4();
40488       jj_la1_init_5();
40489       jj_la1_init_6();
40490       jj_la1_init_7();
40491       jj_la1_init_8();
40492       jj_la1_init_9();
40493       jj_la1_init_10();
40494       jj_la1_init_11();
40495       jj_la1_init_12();
40496       jj_la1_init_13();
40497    }
40498    private static void jj_la1_init_0() {
40499       jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40500    }
40501    private static void jj_la1_init_1() {
40502       jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40503    }
40504    private static void jj_la1_init_2() {
40505       jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40506    }
40507    private static void jj_la1_init_3() {
40508       jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40509    }
40510    private static void jj_la1_init_4() {
40511       jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40512    }
40513    private static void jj_la1_init_5() {
40514       jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x64b6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40515    }
40516    private static void jj_la1_init_6() {
40517       jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40518    }
40519    private static void jj_la1_init_7() {
40520       jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40521    }
40522    private static void jj_la1_init_8() {
40523       jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40524    }
40525    private static void jj_la1_init_9() {
40526       jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40527    }
40528    private static void jj_la1_init_10() {
40529       jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40530    }
40531    private static void jj_la1_init_11() {
40532       jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40533    }
40534    private static void jj_la1_init_12() {
40535       jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40536    }
40537    private static void jj_la1_init_13() {
40538       jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40539    }
40540   final private JJCalls[] jj_2_rtns = new JJCalls[85];
40541   private boolean jj_rescan = false;
40542   private int jj_gc = 0;
40543 
40544   /** Constructor with InputStream. */
40545   public PLSQLParser(java.io.InputStream stream) {
40546      this(stream, null);
40547   }
40548   /** Constructor with InputStream and supplied encoding */
40549   public PLSQLParser(java.io.InputStream stream, String encoding) {
40550     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40551     token_source = new PLSQLParserTokenManager(jj_input_stream);
40552     token = new Token();
40553     token.next = jj_nt = token_source.getNextToken();
40554     jj_gen = 0;
40555     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40556     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40557   }
40558 
40559   /** Reinitialise. */
40560   public void ReInit(java.io.InputStream stream) {
40561      ReInit(stream, null);
40562   }
40563   /** Reinitialise. */
40564   public void ReInit(java.io.InputStream stream, String encoding) {
40565     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40566     token_source.ReInit(jj_input_stream);
40567     token = new Token();
40568     token.next = jj_nt = token_source.getNextToken();
40569     jjtree.reset();
40570     jj_gen = 0;
40571     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40572     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40573   }
40574 
40575   /** Constructor. */
40576   public PLSQLParser(java.io.Reader stream) {
40577     jj_input_stream = new SimpleCharStream(stream, 1, 1);
40578     token_source = new PLSQLParserTokenManager(jj_input_stream);
40579     token = new Token();
40580     token.next = jj_nt = token_source.getNextToken();
40581     jj_gen = 0;
40582     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40583     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40584   }
40585 
40586   /** Reinitialise. */
40587   public void ReInit(java.io.Reader stream) {
40588     jj_input_stream.ReInit(stream, 1, 1);
40589     token_source.ReInit(jj_input_stream);
40590     token = new Token();
40591     token.next = jj_nt = token_source.getNextToken();
40592     jjtree.reset();
40593     jj_gen = 0;
40594     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40595     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40596   }
40597 
40598   /** Constructor with generated Token Manager. */
40599   public PLSQLParser(PLSQLParserTokenManager tm) {
40600     token_source = tm;
40601     token = new Token();
40602     token.next = jj_nt = token_source.getNextToken();
40603     jj_gen = 0;
40604     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40605     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40606   }
40607 
40608   /** Reinitialise. */
40609   public void ReInit(PLSQLParserTokenManager tm) {
40610     token_source = tm;
40611     token = new Token();
40612     token.next = jj_nt = token_source.getNextToken();
40613     jjtree.reset();
40614     jj_gen = 0;
40615     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40616     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40617   }
40618 
40619   private Token jj_consume_token(int kind) throws ParseException {
40620     Token oldToken = token;
40621     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40622     else jj_nt = jj_nt.next = token_source.getNextToken();
40623     if (token.kind == kind) {
40624       jj_gen++;
40625       if (++jj_gc > 100) {
40626         jj_gc = 0;
40627         for (int i = 0; i < jj_2_rtns.length; i++) {
40628           JJCalls c = jj_2_rtns[i];
40629           while (c != null) {
40630             if (c.gen < jj_gen) c.first = null;
40631             c = c.next;
40632           }
40633         }
40634       }
40635       return token;
40636     }
40637     jj_nt = token;
40638     token = oldToken;
40639     jj_kind = kind;
40640     throw generateParseException();
40641   }
40642 
40643   static private final class LookaheadSuccess extends java.lang.Error { }
40644   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40645   private boolean jj_scan_token(int kind) {
40646     if (jj_scanpos == jj_lastpos) {
40647       jj_la--;
40648       if (jj_scanpos.next == null) {
40649         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40650       } else {
40651         jj_lastpos = jj_scanpos = jj_scanpos.next;
40652       }
40653     } else {
40654       jj_scanpos = jj_scanpos.next;
40655     }
40656     if (jj_rescan) {
40657       int i = 0; Token tok = token;
40658       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40659       if (tok != null) jj_add_error_token(kind, i);
40660     }
40661     if (jj_scanpos.kind != kind) return true;
40662     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40663     return false;
40664   }
40665 
40666 
40667 /** Get the next Token. */
40668   final public Token getNextToken() {
40669     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40670     else jj_nt = jj_nt.next = token_source.getNextToken();
40671     jj_gen++;
40672     return token;
40673   }
40674 
40675 /** Get the specific Token. */
40676   final public Token getToken(int index) {
40677     Token t = token;
40678     for (int i = 0; i < index; i++) {
40679       if (t.next != null) t = t.next;
40680       else t = t.next = token_source.getNextToken();
40681     }
40682     return t;
40683   }
40684 
40685   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40686   private int[] jj_expentry;
40687   private int jj_kind = -1;
40688   private int[] jj_lasttokens = new int[100];
40689   private int jj_endpos;
40690 
40691   private void jj_add_error_token(int kind, int pos) {
40692     if (pos >= 100) return;
40693     if (pos == jj_endpos + 1) {
40694       jj_lasttokens[jj_endpos++] = kind;
40695     } else if (jj_endpos != 0) {
40696       jj_expentry = new int[jj_endpos];
40697       for (int i = 0; i < jj_endpos; i++) {
40698         jj_expentry[i] = jj_lasttokens[i];
40699       }
40700       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40701         int[] oldentry = (int[])(it.next());
40702         if (oldentry.length == jj_expentry.length) {
40703           for (int i = 0; i < jj_expentry.length; i++) {
40704             if (oldentry[i] != jj_expentry[i]) {
40705               continue jj_entries_loop;
40706             }
40707           }
40708           jj_expentries.add(jj_expentry);
40709           break jj_entries_loop;
40710         }
40711       }
40712       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40713     }
40714   }
40715 
40716   /** Generate ParseException. */
40717   public ParseException generateParseException() {
40718     jj_expentries.clear();
40719     boolean[] la1tokens = new boolean[434];
40720     if (jj_kind >= 0) {
40721       la1tokens[jj_kind] = true;
40722       jj_kind = -1;
40723     }
40724     for (int i = 0; i < 460; i++) {
40725       if (jj_la1[i] == jj_gen) {
40726         for (int j = 0; j < 32; j++) {
40727           if ((jj_la1_0[i] & (1<<j)) != 0) {
40728             la1tokens[j] = true;
40729           }
40730           if ((jj_la1_1[i] & (1<<j)) != 0) {
40731             la1tokens[32+j] = true;
40732           }
40733           if ((jj_la1_2[i] & (1<<j)) != 0) {
40734             la1tokens[64+j] = true;
40735           }
40736           if ((jj_la1_3[i] & (1<<j)) != 0) {
40737             la1tokens[96+j] = true;
40738           }
40739           if ((jj_la1_4[i] & (1<<j)) != 0) {
40740             la1tokens[128+j] = true;
40741           }
40742           if ((jj_la1_5[i] & (1<<j)) != 0) {
40743             la1tokens[160+j] = true;
40744           }
40745           if ((jj_la1_6[i] & (1<<j)) != 0) {
40746             la1tokens[192+j] = true;
40747           }
40748           if ((jj_la1_7[i] & (1<<j)) != 0) {
40749             la1tokens[224+j] = true;
40750           }
40751           if ((jj_la1_8[i] & (1<<j)) != 0) {
40752             la1tokens[256+j] = true;
40753           }
40754           if ((jj_la1_9[i] & (1<<j)) != 0) {
40755             la1tokens[288+j] = true;
40756           }
40757           if ((jj_la1_10[i] & (1<<j)) != 0) {
40758             la1tokens[320+j] = true;
40759           }
40760           if ((jj_la1_11[i] & (1<<j)) != 0) {
40761             la1tokens[352+j] = true;
40762           }
40763           if ((jj_la1_12[i] & (1<<j)) != 0) {
40764             la1tokens[384+j] = true;
40765           }
40766           if ((jj_la1_13[i] & (1<<j)) != 0) {
40767             la1tokens[416+j] = true;
40768           }
40769         }
40770       }
40771     }
40772     for (int i = 0; i < 434; i++) {
40773       if (la1tokens[i]) {
40774         jj_expentry = new int[1];
40775         jj_expentry[0] = i;
40776         jj_expentries.add(jj_expentry);
40777       }
40778     }
40779     jj_endpos = 0;
40780     jj_rescan_token();
40781     jj_add_error_token(0, 0);
40782     int[][] exptokseq = new int[jj_expentries.size()][];
40783     for (int i = 0; i < jj_expentries.size(); i++) {
40784       exptokseq[i] = jj_expentries.get(i);
40785     }
40786     return new ParseException(token, exptokseq, tokenImage);
40787   }
40788 
40789   /** Enable tracing. */
40790   final public void enable_tracing() {
40791   }
40792 
40793   /** Disable tracing. */
40794   final public void disable_tracing() {
40795   }
40796 
40797   private void jj_rescan_token() {
40798     jj_rescan = true;
40799     for (int i = 0; i < 85; i++) {
40800     try {
40801       JJCalls p = jj_2_rtns[i];
40802       do {
40803         if (p.gen > jj_gen) {
40804           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40805           switch (i) {
40806             case 0: jj_3_1(); break;
40807             case 1: jj_3_2(); break;
40808             case 2: jj_3_3(); break;
40809             case 3: jj_3_4(); break;
40810             case 4: jj_3_5(); break;
40811             case 5: jj_3_6(); break;
40812             case 6: jj_3_7(); break;
40813             case 7: jj_3_8(); break;
40814             case 8: jj_3_9(); break;
40815             case 9: jj_3_10(); break;
40816             case 10: jj_3_11(); break;
40817             case 11: jj_3_12(); break;
40818             case 12: jj_3_13(); break;
40819             case 13: jj_3_14(); break;
40820             case 14: jj_3_15(); break;
40821             case 15: jj_3_16(); break;
40822             case 16: jj_3_17(); break;
40823             case 17: jj_3_18(); break;
40824             case 18: jj_3_19(); break;
40825             case 19: jj_3_20(); break;
40826             case 20: jj_3_21(); break;
40827             case 21: jj_3_22(); break;
40828             case 22: jj_3_23(); break;
40829             case 23: jj_3_24(); break;
40830             case 24: jj_3_25(); break;
40831             case 25: jj_3_26(); break;
40832             case 26: jj_3_27(); break;
40833             case 27: jj_3_28(); break;
40834             case 28: jj_3_29(); break;
40835             case 29: jj_3_30(); break;
40836             case 30: jj_3_31(); break;
40837             case 31: jj_3_32(); break;
40838             case 32: jj_3_33(); break;
40839             case 33: jj_3_34(); break;
40840             case 34: jj_3_35(); break;
40841             case 35: jj_3_36(); break;
40842             case 36: jj_3_37(); break;
40843             case 37: jj_3_38(); break;
40844             case 38: jj_3_39(); break;
40845             case 39: jj_3_40(); break;
40846             case 40: jj_3_41(); break;
40847             case 41: jj_3_42(); break;
40848             case 42: jj_3_43(); break;
40849             case 43: jj_3_44(); break;
40850             case 44: jj_3_45(); break;
40851             case 45: jj_3_46(); break;
40852             case 46: jj_3_47(); break;
40853             case 47: jj_3_48(); break;
40854             case 48: jj_3_49(); break;
40855             case 49: jj_3_50(); break;
40856             case 50: jj_3_51(); break;
40857             case 51: jj_3_52(); break;
40858             case 52: jj_3_53(); break;
40859             case 53: jj_3_54(); break;
40860             case 54: jj_3_55(); break;
40861             case 55: jj_3_56(); break;
40862             case 56: jj_3_57(); break;
40863             case 57: jj_3_58(); break;
40864             case 58: jj_3_59(); break;
40865             case 59: jj_3_60(); break;
40866             case 60: jj_3_61(); break;
40867             case 61: jj_3_62(); break;
40868             case 62: jj_3_63(); break;
40869             case 63: jj_3_64(); break;
40870             case 64: jj_3_65(); break;
40871             case 65: jj_3_66(); break;
40872             case 66: jj_3_67(); break;
40873             case 67: jj_3_68(); break;
40874             case 68: jj_3_69(); break;
40875             case 69: jj_3_70(); break;
40876             case 70: jj_3_71(); break;
40877             case 71: jj_3_72(); break;
40878             case 72: jj_3_73(); break;
40879             case 73: jj_3_74(); break;
40880             case 74: jj_3_75(); break;
40881             case 75: jj_3_76(); break;
40882             case 76: jj_3_77(); break;
40883             case 77: jj_3_78(); break;
40884             case 78: jj_3_79(); break;
40885             case 79: jj_3_80(); break;
40886             case 80: jj_3_81(); break;
40887             case 81: jj_3_82(); break;
40888             case 82: jj_3_83(); break;
40889             case 83: jj_3_84(); break;
40890             case 84: jj_3_85(); break;
40891           }
40892         }
40893         p = p.next;
40894       } while (p != null);
40895       } catch(LookaheadSuccess ls) { }
40896     }
40897     jj_rescan = false;
40898   }
40899 
40900   private void jj_save(int index, int xla) {
40901     JJCalls p = jj_2_rtns[index];
40902     while (p.gen > jj_gen) {
40903       if (p.next == null) { p = p.next = new JJCalls(); break; }
40904       p = p.next;
40905     }
40906     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40907   }
40908 
40909   static final class JJCalls {
40910     int gen;
40911     Token first;
40912     int arg;
40913     JJCalls next;
40914   }
40915 
40916 }